diff --git a/TODO b/TODO
deleted file mode 100644
index 8418412..0000000
--- a/TODO
+++ /dev/null
@@ -1,9 +0,0 @@
-Pending tasks:
-
-- Add detection of more exploits/vulns
-- Documentation of methods in PDFCore.py
-- Add the rest of supported stream filters (better testing of existent)
-- Automatic analysis of embedded PDF files
-- Improve the automatic Javascript analysis, getting code from other parts of the documents (getAnnots, etc)
-- GUI
-- ...
\ No newline at end of file
diff --git a/aespython/__init__.py b/aespython/__init__.py
deleted file mode 100644
index e69de29..0000000
diff --git a/aespython/aes_cipher.py b/aespython/aes_cipher.py
deleted file mode 100644
index fdf4c5d..0000000
--- a/aespython/aes_cipher.py
+++ /dev/null
@@ -1,64 +0,0 @@
-#!/usr/bin/env python
-"""
-AES Block Cipher.
-
-Performs single block cipher decipher operations on a 16 element list of integers.
-These integers represent 8 bit bytes in a 128 bit block.
-The result of cipher or decipher operations is the transformed 16 element list of integers.
-
-Running this file as __main__ will result in a self-test of the algorithm.
-
-Algorithm per NIST FIPS-197 http://csrc.nist.gov/publications/fips/fips197/fips-197.pdf
-
-Copyright (c) 2010, Adam Newman http://www.caller9.com/
-Licensed under the MIT license http://www.opensource.org/licenses/mit-license.php
-"""
-__author__ = "Adam Newman"
-
-#Normally use relative import. In test mode use local import.
-try:from .aes_tables import sbox,i_sbox,galI,galNI
-except ValueError:from aes_tables import sbox,i_sbox,galI,galNI
-ups=",".join("s%x"%x for x in range(16))
-upr=ups.replace("s","r")
-mix=",".join(",".join(("g{0}[s%x]^g{1}[s%x]^g{2}[s%x]^g{3}[s%x]^r%x"%(i+(i[0]+(0,3,2,1)[j],))).format(j&3,j+1&3,j+2&3,j+3&3) for j in (0,3,2,1)) for i in ((0,1,2,3),(4,5,6,7),(8,9,10,11),(12,13,14,15))).replace("g2","g").replace("g3","g")
-i=mix.find("g[")
-while i!=-1:
- mix=mix[:i]+mix[i+2:i+4]+mix[i+5:]
- i=mix.find("g[",i)
-imix=",".join(",".join(("g{0}[s%x]^g{1}[s%x]^g{2}[s%x]^g{3}[s%x]"%i).format(j&3,j+1&3,j+2&3,j+3&3) for j in (0,3,2,1)) for i in ((0,1,2,3),(4,5,6,7),(8,9,10,11),(12,13,14,15)))
-csl=["s%x"%(x*5&15) for x in range(16)]
-csr=["s%x"%(x*-3&15) for x in range(16)]
-box=",".join("s[%s]"%i for i in csl)
-ibox=",".join("s[%s]^r%x"%i for i in zip(csr,range(16)))
-xor=",".join("s[%s]^r%x"%i for i in zip(csl,range(16)))
-xori=";".join("s%x^=r%x"%(i,i) for i in range(16))
-ciph="""def decipher_block(f,s):
- g0,g1,g2,g3=galNI;ek=f._expanded_key;S=s+[0]*(16-len(s));s=sbox;R=ek[:16];X
- for f in range(!16):R=ek[f:f+16];S=B;S=M
- R=ek[f+16:]
- return """.replace("S",ups).replace("R",upr).replace("X",xori)
-class AESCipher:
- def __init__(self,expanded_key):
- self._expanded_key=expanded_key
- self._Nr=len(expanded_key)-16
- exec(ciph.replace("g2,g3","").replace("dec","c").replace("!","16,f._Nr,").replace("B",box).replace("M",mix)+xor)
- exec(ciph.replace("NI","I").replace(":16","f._Nr:").replace("f+16:",":16").replace("!","f._Nr-16,0,-").replace("sbox","i_sbox").replace("B",ibox).replace("M",imix)+ibox)
-import unittest
-class TestCipher(unittest.TestCase):
- def test_cipher(self):
- """Test AES cipher with all key lengths"""
- import test_keys
- import key_expander
- test_data = test_keys.TestKeys()
- for key_size in 128, 192, 256:
- test_key_expander = key_expander.KeyExpander(key_size)
- test_expanded_key = test_key_expander.expand(test_data.test_key[key_size])
- test_cipher = AESCipher(test_expanded_key)
- test_result_ciphertext = test_cipher.cipher_block(test_data.test_block_plaintext)
- self.assertEquals(len([i for i, j in zip(test_result_ciphertext, test_data.test_block_ciphertext_validated[key_size]) if i == j]),
- 16,msg='Test %d bit cipher'%key_size)
- test_result_plaintext = test_cipher.decipher_block(test_data.test_block_ciphertext_validated[key_size])
- self.assertEquals(len([i for i, j in zip(test_result_plaintext, test_data.test_block_plaintext) if i == j]),
- 16,msg='Test %d bit decipher'%key_size)
-if __name__ == "__main__":
- unittest.main()
\ No newline at end of file
diff --git a/aespython/aes_tables.py b/aespython/aes_tables.py
deleted file mode 100644
index bf6eb55..0000000
--- a/aespython/aes_tables.py
+++ /dev/null
@@ -1,156 +0,0 @@
-"""
-Instantiate AES tables for rcon,sbox,i_sbox,and galois_lookup.
-
-Copyright (c) 2010,Adam Newman http://www.caller9.com/
-Licensed under the MIT license http://www.opensource.org/licenses/mit-license.php
-"""
-__author__ = "Adam Newman"
-rcon=(
-0x8d,0x01,0x02,0x04,0x08,0x10,0x20,0x40,0x80,0x1b,0x36,0x6c,0xd8,0xab,0x4d,0x9a,
-0x2f,0x5e,0xbc,0x63,0xc6,0x97,0x35,0x6a,0xd4,0xb3,0x7d,0xfa,0xef,0xc5,0x91,0x39,
-0x72,0xe4,0xd3,0xbd,0x61,0xc2,0x9f,0x25,0x4a,0x94,0x33,0x66,0xcc,0x83,0x1d,0x3a,
-0x74,0xe8,0xcb,0x8d,0x01,0x02,0x04,0x08,0x10,0x20,0x40,0x80,0x1b,0x36,0x6c,0xd8,
-0xab,0x4d,0x9a,0x2f,0x5e,0xbc,0x63,0xc6,0x97,0x35,0x6a,0xd4,0xb3,0x7d,0xfa,0xef,
-0xc5,0x91,0x39,0x72,0xe4,0xd3,0xbd,0x61,0xc2,0x9f,0x25,0x4a,0x94,0x33,0x66,0xcc,
-0x83,0x1d,0x3a,0x74,0xe8,0xcb,0x8d,0x01,0x02,0x04,0x08,0x10,0x20,0x40,0x80,0x1b,
-0x36,0x6c,0xd8,0xab,0x4d,0x9a,0x2f,0x5e,0xbc,0x63,0xc6,0x97,0x35,0x6a,0xd4,0xb3,
-0x7d,0xfa,0xef,0xc5,0x91,0x39,0x72,0xe4,0xd3,0xbd,0x61,0xc2,0x9f,0x25,0x4a,0x94,
-0x33,0x66,0xcc,0x83,0x1d,0x3a,0x74,0xe8,0xcb,0x8d,0x01,0x02,0x04,0x08,0x10,0x20,
-0x40,0x80,0x1b,0x36,0x6c,0xd8,0xab,0x4d,0x9a,0x2f,0x5e,0xbc,0x63,0xc6,0x97,0x35,
-0x6a,0xd4,0xb3,0x7d,0xfa,0xef,0xc5,0x91,0x39,0x72,0xe4,0xd3,0xbd,0x61,0xc2,0x9f,
-0x25,0x4a,0x94,0x33,0x66,0xcc,0x83,0x1d,0x3a,0x74,0xe8,0xcb,0x8d,0x01,0x02,0x04,
-0x08,0x10,0x20,0x40,0x80,0x1b,0x36,0x6c,0xd8,0xab,0x4d,0x9a,0x2f,0x5e,0xbc,0x63,
-0xc6,0x97,0x35,0x6a,0xd4,0xb3,0x7d,0xfa,0xef,0xc5,0x91,0x39,0x72,0xe4,0xd3,0xbd,
-0x61,0xc2,0x9f,0x25,0x4a,0x94,0x33,0x66,0xcc,0x83,0x1d,0x3a,0x74,0xe8,0xcb)
-sbox=(
-0x63,0x7c,0x77,0x7b,0xf2,0x6b,0x6f,0xc5,0x30,0x01,0x67,0x2b,0xfe,0xd7,0xab,0x76,
-0xca,0x82,0xc9,0x7d,0xfa,0x59,0x47,0xf0,0xad,0xd4,0xa2,0xaf,0x9c,0xa4,0x72,0xc0,
-0xb7,0xfd,0x93,0x26,0x36,0x3f,0xf7,0xcc,0x34,0xa5,0xe5,0xf1,0x71,0xd8,0x31,0x15,
-0x04,0xc7,0x23,0xc3,0x18,0x96,0x05,0x9a,0x07,0x12,0x80,0xe2,0xeb,0x27,0xb2,0x75,
-0x09,0x83,0x2c,0x1a,0x1b,0x6e,0x5a,0xa0,0x52,0x3b,0xd6,0xb3,0x29,0xe3,0x2f,0x84,
-0x53,0xd1,0x00,0xed,0x20,0xfc,0xb1,0x5b,0x6a,0xcb,0xbe,0x39,0x4a,0x4c,0x58,0xcf,
-0xd0,0xef,0xaa,0xfb,0x43,0x4d,0x33,0x85,0x45,0xf9,0x02,0x7f,0x50,0x3c,0x9f,0xa8,
-0x51,0xa3,0x40,0x8f,0x92,0x9d,0x38,0xf5,0xbc,0xb6,0xda,0x21,0x10,0xff,0xf3,0xd2,
-0xcd,0x0c,0x13,0xec,0x5f,0x97,0x44,0x17,0xc4,0xa7,0x7e,0x3d,0x64,0x5d,0x19,0x73,
-0x60,0x81,0x4f,0xdc,0x22,0x2a,0x90,0x88,0x46,0xee,0xb8,0x14,0xde,0x5e,0x0b,0xdb,
-0xe0,0x32,0x3a,0x0a,0x49,0x06,0x24,0x5c,0xc2,0xd3,0xac,0x62,0x91,0x95,0xe4,0x79,
-0xe7,0xc8,0x37,0x6d,0x8d,0xd5,0x4e,0xa9,0x6c,0x56,0xf4,0xea,0x65,0x7a,0xae,0x08,
-0xba,0x78,0x25,0x2e,0x1c,0xa6,0xb4,0xc6,0xe8,0xdd,0x74,0x1f,0x4b,0xbd,0x8b,0x8a,
-0x70,0x3e,0xb5,0x66,0x48,0x03,0xf6,0x0e,0x61,0x35,0x57,0xb9,0x86,0xc1,0x1d,0x9e,
-0xe1,0xf8,0x98,0x11,0x69,0xd9,0x8e,0x94,0x9b,0x1e,0x87,0xe9,0xce,0x55,0x28,0xdf,
-0x8c,0xa1,0x89,0x0d,0xbf,0xe6,0x42,0x68,0x41,0x99,0x2d,0x0f,0xb0,0x54,0xbb,0x16)
-i_sbox=(
-0x52,0x09,0x6a,0xd5,0x30,0x36,0xa5,0x38,0xbf,0x40,0xa3,0x9e,0x81,0xf3,0xd7,0xfb,
-0x7c,0xe3,0x39,0x82,0x9b,0x2f,0xff,0x87,0x34,0x8e,0x43,0x44,0xc4,0xde,0xe9,0xcb,
-0x54,0x7b,0x94,0x32,0xa6,0xc2,0x23,0x3d,0xee,0x4c,0x95,0x0b,0x42,0xfa,0xc3,0x4e,
-0x08,0x2e,0xa1,0x66,0x28,0xd9,0x24,0xb2,0x76,0x5b,0xa2,0x49,0x6d,0x8b,0xd1,0x25,
-0x72,0xf8,0xf6,0x64,0x86,0x68,0x98,0x16,0xd4,0xa4,0x5c,0xcc,0x5d,0x65,0xb6,0x92,
-0x6c,0x70,0x48,0x50,0xfd,0xed,0xb9,0xda,0x5e,0x15,0x46,0x57,0xa7,0x8d,0x9d,0x84,
-0x90,0xd8,0xab,0x00,0x8c,0xbc,0xd3,0x0a,0xf7,0xe4,0x58,0x05,0xb8,0xb3,0x45,0x06,
-0xd0,0x2c,0x1e,0x8f,0xca,0x3f,0x0f,0x02,0xc1,0xaf,0xbd,0x03,0x01,0x13,0x8a,0x6b,
-0x3a,0x91,0x11,0x41,0x4f,0x67,0xdc,0xea,0x97,0xf2,0xcf,0xce,0xf0,0xb4,0xe6,0x73,
-0x96,0xac,0x74,0x22,0xe7,0xad,0x35,0x85,0xe2,0xf9,0x37,0xe8,0x1c,0x75,0xdf,0x6e,
-0x47,0xf1,0x1a,0x71,0x1d,0x29,0xc5,0x89,0x6f,0xb7,0x62,0x0e,0xaa,0x18,0xbe,0x1b,
-0xfc,0x56,0x3e,0x4b,0xc6,0xd2,0x79,0x20,0x9a,0xdb,0xc0,0xfe,0x78,0xcd,0x5a,0xf4,
-0x1f,0xdd,0xa8,0x33,0x88,0x07,0xc7,0x31,0xb1,0x12,0x10,0x59,0x27,0x80,0xec,0x5f,
-0x60,0x51,0x7f,0xa9,0x19,0xb5,0x4a,0x0d,0x2d,0xe5,0x7a,0x9f,0x93,0xc9,0x9c,0xef,
-0xa0,0xe0,0x3b,0x4d,0xae,0x2a,0xf5,0xb0,0xc8,0xeb,0xbb,0x3c,0x83,0x53,0x99,0x61,
-0x17,0x2b,0x04,0x7e,0xba,0x77,0xd6,0x26,0xe1,0x69,0x14,0x63,0x55,0x21,0x0c,0x7d)
-galNI=((
-0x00,0x02,0x04,0x06,0x08,0x0a,0x0c,0x0e,0x10,0x12,0x14,0x16,0x18,0x1a,0x1c,0x1e,
-0x20,0x22,0x24,0x26,0x28,0x2a,0x2c,0x2e,0x30,0x32,0x34,0x36,0x38,0x3a,0x3c,0x3e,
-0x40,0x42,0x44,0x46,0x48,0x4a,0x4c,0x4e,0x50,0x52,0x54,0x56,0x58,0x5a,0x5c,0x5e,
-0x60,0x62,0x64,0x66,0x68,0x6a,0x6c,0x6e,0x70,0x72,0x74,0x76,0x78,0x7a,0x7c,0x7e,
-0x80,0x82,0x84,0x86,0x88,0x8a,0x8c,0x8e,0x90,0x92,0x94,0x96,0x98,0x9a,0x9c,0x9e,
-0xa0,0xa2,0xa4,0xa6,0xa8,0xaa,0xac,0xae,0xb0,0xb2,0xb4,0xb6,0xb8,0xba,0xbc,0xbe,
-0xc0,0xc2,0xc4,0xc6,0xc8,0xca,0xcc,0xce,0xd0,0xd2,0xd4,0xd6,0xd8,0xda,0xdc,0xde,
-0xe0,0xe2,0xe4,0xe6,0xe8,0xea,0xec,0xee,0xf0,0xf2,0xf4,0xf6,0xf8,0xfa,0xfc,0xfe,
-0x1b,0x19,0x1f,0x1d,0x13,0x11,0x17,0x15,0x0b,0x09,0x0f,0x0d,0x03,0x01,0x07,0x05,
-0x3b,0x39,0x3f,0x3d,0x33,0x31,0x37,0x35,0x2b,0x29,0x2f,0x2d,0x23,0x21,0x27,0x25,
-0x5b,0x59,0x5f,0x5d,0x53,0x51,0x57,0x55,0x4b,0x49,0x4f,0x4d,0x43,0x41,0x47,0x45,
-0x7b,0x79,0x7f,0x7d,0x73,0x71,0x77,0x75,0x6b,0x69,0x6f,0x6d,0x63,0x61,0x67,0x65,
-0x9b,0x99,0x9f,0x9d,0x93,0x91,0x97,0x95,0x8b,0x89,0x8f,0x8d,0x83,0x81,0x87,0x85,
-0xbb,0xb9,0xbf,0xbd,0xb3,0xb1,0xb7,0xb5,0xab,0xa9,0xaf,0xad,0xa3,0xa1,0xa7,0xa5,
-0xdb,0xd9,0xdf,0xdd,0xd3,0xd1,0xd7,0xd5,0xcb,0xc9,0xcf,0xcd,0xc3,0xc1,0xc7,0xc5,
-0xfb,0xf9,0xff,0xfd,0xf3,0xf1,0xf7,0xf5,0xeb,0xe9,0xef,0xed,0xe3,0xe1,0xe7,0xe5),
-(0x00,0x03,0x06,0x05,0x0c,0x0f,0x0a,0x09,0x18,0x1b,0x1e,0x1d,0x14,0x17,0x12,0x11,
-0x30,0x33,0x36,0x35,0x3c,0x3f,0x3a,0x39,0x28,0x2b,0x2e,0x2d,0x24,0x27,0x22,0x21,
-0x60,0x63,0x66,0x65,0x6c,0x6f,0x6a,0x69,0x78,0x7b,0x7e,0x7d,0x74,0x77,0x72,0x71,
-0x50,0x53,0x56,0x55,0x5c,0x5f,0x5a,0x59,0x48,0x4b,0x4e,0x4d,0x44,0x47,0x42,0x41,
-0xc0,0xc3,0xc6,0xc5,0xcc,0xcf,0xca,0xc9,0xd8,0xdb,0xde,0xdd,0xd4,0xd7,0xd2,0xd1,
-0xf0,0xf3,0xf6,0xf5,0xfc,0xff,0xfa,0xf9,0xe8,0xeb,0xee,0xed,0xe4,0xe7,0xe2,0xe1,
-0xa0,0xa3,0xa6,0xa5,0xac,0xaf,0xaa,0xa9,0xb8,0xbb,0xbe,0xbd,0xb4,0xb7,0xb2,0xb1,
-0x90,0x93,0x96,0x95,0x9c,0x9f,0x9a,0x99,0x88,0x8b,0x8e,0x8d,0x84,0x87,0x82,0x81,
-0x9b,0x98,0x9d,0x9e,0x97,0x94,0x91,0x92,0x83,0x80,0x85,0x86,0x8f,0x8c,0x89,0x8a,
-0xab,0xa8,0xad,0xae,0xa7,0xa4,0xa1,0xa2,0xb3,0xb0,0xb5,0xb6,0xbf,0xbc,0xb9,0xba,
-0xfb,0xf8,0xfd,0xfe,0xf7,0xf4,0xf1,0xf2,0xe3,0xe0,0xe5,0xe6,0xef,0xec,0xe9,0xea,
-0xcb,0xc8,0xcd,0xce,0xc7,0xc4,0xc1,0xc2,0xd3,0xd0,0xd5,0xd6,0xdf,0xdc,0xd9,0xda,
-0x5b,0x58,0x5d,0x5e,0x57,0x54,0x51,0x52,0x43,0x40,0x45,0x46,0x4f,0x4c,0x49,0x4a,
-0x6b,0x68,0x6d,0x6e,0x67,0x64,0x61,0x62,0x73,0x70,0x75,0x76,0x7f,0x7c,0x79,0x7a,
-0x3b,0x38,0x3d,0x3e,0x37,0x34,0x31,0x32,0x23,0x20,0x25,0x26,0x2f,0x2c,0x29,0x2a,
-0x0b,0x08,0x0d,0x0e,0x07,0x04,0x01,0x02,0x13,0x10,0x15,0x16,0x1f,0x1c,0x19,0x1a))
-galI=(
-(0x00,0x0e,0x1c,0x12,0x38,0x36,0x24,0x2a,0x70,0x7e,0x6c,0x62,0x48,0x46,0x54,0x5a,
-0xe0,0xee,0xfc,0xf2,0xd8,0xd6,0xc4,0xca,0x90,0x9e,0x8c,0x82,0xa8,0xa6,0xb4,0xba,
-0xdb,0xd5,0xc7,0xc9,0xe3,0xed,0xff,0xf1,0xab,0xa5,0xb7,0xb9,0x93,0x9d,0x8f,0x81,
-0x3b,0x35,0x27,0x29,0x03,0x0d,0x1f,0x11,0x4b,0x45,0x57,0x59,0x73,0x7d,0x6f,0x61,
-0xad,0xa3,0xb1,0xbf,0x95,0x9b,0x89,0x87,0xdd,0xd3,0xc1,0xcf,0xe5,0xeb,0xf9,0xf7,
-0x4d,0x43,0x51,0x5f,0x75,0x7b,0x69,0x67,0x3d,0x33,0x21,0x2f,0x05,0x0b,0x19,0x17,
-0x76,0x78,0x6a,0x64,0x4e,0x40,0x52,0x5c,0x06,0x08,0x1a,0x14,0x3e,0x30,0x22,0x2c,
-0x96,0x98,0x8a,0x84,0xae,0xa0,0xb2,0xbc,0xe6,0xe8,0xfa,0xf4,0xde,0xd0,0xc2,0xcc,
-0x41,0x4f,0x5d,0x53,0x79,0x77,0x65,0x6b,0x31,0x3f,0x2d,0x23,0x09,0x07,0x15,0x1b,
-0xa1,0xaf,0xbd,0xb3,0x99,0x97,0x85,0x8b,0xd1,0xdf,0xcd,0xc3,0xe9,0xe7,0xf5,0xfb,
-0x9a,0x94,0x86,0x88,0xa2,0xac,0xbe,0xb0,0xea,0xe4,0xf6,0xf8,0xd2,0xdc,0xce,0xc0,
-0x7a,0x74,0x66,0x68,0x42,0x4c,0x5e,0x50,0x0a,0x04,0x16,0x18,0x32,0x3c,0x2e,0x20,
-0xec,0xe2,0xf0,0xfe,0xd4,0xda,0xc8,0xc6,0x9c,0x92,0x80,0x8e,0xa4,0xaa,0xb8,0xb6,
-0x0c,0x02,0x10,0x1e,0x34,0x3a,0x28,0x26,0x7c,0x72,0x60,0x6e,0x44,0x4a,0x58,0x56,
-0x37,0x39,0x2b,0x25,0x0f,0x01,0x13,0x1d,0x47,0x49,0x5b,0x55,0x7f,0x71,0x63,0x6d,
-0xd7,0xd9,0xcb,0xc5,0xef,0xe1,0xf3,0xfd,0xa7,0xa9,0xbb,0xb5,0x9f,0x91,0x83,0x8d),
-(0x00,0x0b,0x16,0x1d,0x2c,0x27,0x3a,0x31,0x58,0x53,0x4e,0x45,0x74,0x7f,0x62,0x69,
-0xb0,0xbb,0xa6,0xad,0x9c,0x97,0x8a,0x81,0xe8,0xe3,0xfe,0xf5,0xc4,0xcf,0xd2,0xd9,
-0x7b,0x70,0x6d,0x66,0x57,0x5c,0x41,0x4a,0x23,0x28,0x35,0x3e,0x0f,0x04,0x19,0x12,
-0xcb,0xc0,0xdd,0xd6,0xe7,0xec,0xf1,0xfa,0x93,0x98,0x85,0x8e,0xbf,0xb4,0xa9,0xa2,
-0xf6,0xfd,0xe0,0xeb,0xda,0xd1,0xcc,0xc7,0xae,0xa5,0xb8,0xb3,0x82,0x89,0x94,0x9f,
-0x46,0x4d,0x50,0x5b,0x6a,0x61,0x7c,0x77,0x1e,0x15,0x08,0x03,0x32,0x39,0x24,0x2f,
-0x8d,0x86,0x9b,0x90,0xa1,0xaa,0xb7,0xbc,0xd5,0xde,0xc3,0xc8,0xf9,0xf2,0xef,0xe4,
-0x3d,0x36,0x2b,0x20,0x11,0x1a,0x07,0x0c,0x65,0x6e,0x73,0x78,0x49,0x42,0x5f,0x54,
-0xf7,0xfc,0xe1,0xea,0xdb,0xd0,0xcd,0xc6,0xaf,0xa4,0xb9,0xb2,0x83,0x88,0x95,0x9e,
-0x47,0x4c,0x51,0x5a,0x6b,0x60,0x7d,0x76,0x1f,0x14,0x09,0x02,0x33,0x38,0x25,0x2e,
-0x8c,0x87,0x9a,0x91,0xa0,0xab,0xb6,0xbd,0xd4,0xdf,0xc2,0xc9,0xf8,0xf3,0xee,0xe5,
-0x3c,0x37,0x2a,0x21,0x10,0x1b,0x06,0x0d,0x64,0x6f,0x72,0x79,0x48,0x43,0x5e,0x55,
-0x01,0x0a,0x17,0x1c,0x2d,0x26,0x3b,0x30,0x59,0x52,0x4f,0x44,0x75,0x7e,0x63,0x68,
-0xb1,0xba,0xa7,0xac,0x9d,0x96,0x8b,0x80,0xe9,0xe2,0xff,0xf4,0xc5,0xce,0xd3,0xd8,
-0x7a,0x71,0x6c,0x67,0x56,0x5d,0x40,0x4b,0x22,0x29,0x34,0x3f,0x0e,0x05,0x18,0x13,
-0xca,0xc1,0xdc,0xd7,0xe6,0xed,0xf0,0xfb,0x92,0x99,0x84,0x8f,0xbe,0xb5,0xa8,0xa3),
-(0x00,0x0d,0x1a,0x17,0x34,0x39,0x2e,0x23,0x68,0x65,0x72,0x7f,0x5c,0x51,0x46,0x4b,
-0xd0,0xdd,0xca,0xc7,0xe4,0xe9,0xfe,0xf3,0xb8,0xb5,0xa2,0xaf,0x8c,0x81,0x96,0x9b,
-0xbb,0xb6,0xa1,0xac,0x8f,0x82,0x95,0x98,0xd3,0xde,0xc9,0xc4,0xe7,0xea,0xfd,0xf0,
-0x6b,0x66,0x71,0x7c,0x5f,0x52,0x45,0x48,0x03,0x0e,0x19,0x14,0x37,0x3a,0x2d,0x20,
-0x6d,0x60,0x77,0x7a,0x59,0x54,0x43,0x4e,0x05,0x08,0x1f,0x12,0x31,0x3c,0x2b,0x26,
-0xbd,0xb0,0xa7,0xaa,0x89,0x84,0x93,0x9e,0xd5,0xd8,0xcf,0xc2,0xe1,0xec,0xfb,0xf6,
-0xd6,0xdb,0xcc,0xc1,0xe2,0xef,0xf8,0xf5,0xbe,0xb3,0xa4,0xa9,0x8a,0x87,0x90,0x9d,
-0x06,0x0b,0x1c,0x11,0x32,0x3f,0x28,0x25,0x6e,0x63,0x74,0x79,0x5a,0x57,0x40,0x4d,
-0xda,0xd7,0xc0,0xcd,0xee,0xe3,0xf4,0xf9,0xb2,0xbf,0xa8,0xa5,0x86,0x8b,0x9c,0x91,
-0x0a,0x07,0x10,0x1d,0x3e,0x33,0x24,0x29,0x62,0x6f,0x78,0x75,0x56,0x5b,0x4c,0x41,
-0x61,0x6c,0x7b,0x76,0x55,0x58,0x4f,0x42,0x09,0x04,0x13,0x1e,0x3d,0x30,0x27,0x2a,
-0xb1,0xbc,0xab,0xa6,0x85,0x88,0x9f,0x92,0xd9,0xd4,0xc3,0xce,0xed,0xe0,0xf7,0xfa,
-0xb7,0xba,0xad,0xa0,0x83,0x8e,0x99,0x94,0xdf,0xd2,0xc5,0xc8,0xeb,0xe6,0xf1,0xfc,
-0x67,0x6a,0x7d,0x70,0x53,0x5e,0x49,0x44,0x0f,0x02,0x15,0x18,0x3b,0x36,0x21,0x2c,
-0x0c,0x01,0x16,0x1b,0x38,0x35,0x22,0x2f,0x64,0x69,0x7e,0x73,0x50,0x5d,0x4a,0x47,
-0xdc,0xd1,0xc6,0xcb,0xe8,0xe5,0xf2,0xff,0xb4,0xb9,0xae,0xa3,0x80,0x8d,0x9a,0x97),
-(0x00,0x09,0x12,0x1b,0x24,0x2d,0x36,0x3f,0x48,0x41,0x5a,0x53,0x6c,0x65,0x7e,0x77,
-0x90,0x99,0x82,0x8b,0xb4,0xbd,0xa6,0xaf,0xd8,0xd1,0xca,0xc3,0xfc,0xf5,0xee,0xe7,
-0x3b,0x32,0x29,0x20,0x1f,0x16,0x0d,0x04,0x73,0x7a,0x61,0x68,0x57,0x5e,0x45,0x4c,
-0xab,0xa2,0xb9,0xb0,0x8f,0x86,0x9d,0x94,0xe3,0xea,0xf1,0xf8,0xc7,0xce,0xd5,0xdc,
-0x76,0x7f,0x64,0x6d,0x52,0x5b,0x40,0x49,0x3e,0x37,0x2c,0x25,0x1a,0x13,0x08,0x01,
-0xe6,0xef,0xf4,0xfd,0xc2,0xcb,0xd0,0xd9,0xae,0xa7,0xbc,0xb5,0x8a,0x83,0x98,0x91,
-0x4d,0x44,0x5f,0x56,0x69,0x60,0x7b,0x72,0x05,0x0c,0x17,0x1e,0x21,0x28,0x33,0x3a,
-0xdd,0xd4,0xcf,0xc6,0xf9,0xf0,0xeb,0xe2,0x95,0x9c,0x87,0x8e,0xb1,0xb8,0xa3,0xaa,
-0xec,0xe5,0xfe,0xf7,0xc8,0xc1,0xda,0xd3,0xa4,0xad,0xb6,0xbf,0x80,0x89,0x92,0x9b,
-0x7c,0x75,0x6e,0x67,0x58,0x51,0x4a,0x43,0x34,0x3d,0x26,0x2f,0x10,0x19,0x02,0x0b,
-0xd7,0xde,0xc5,0xcc,0xf3,0xfa,0xe1,0xe8,0x9f,0x96,0x8d,0x84,0xbb,0xb2,0xa9,0xa0,
-0x47,0x4e,0x55,0x5c,0x63,0x6a,0x71,0x78,0x0f,0x06,0x1d,0x14,0x2b,0x22,0x39,0x30,
-0x9a,0x93,0x88,0x81,0xbe,0xb7,0xac,0xa5,0xd2,0xdb,0xc0,0xc9,0xf6,0xff,0xe4,0xed,
-0x0a,0x03,0x18,0x11,0x2e,0x27,0x3c,0x35,0x42,0x4b,0x50,0x59,0x66,0x6f,0x74,0x7d,
-0xa1,0xa8,0xb3,0xba,0x85,0x8c,0x97,0x9e,0xe9,0xe0,0xfb,0xf2,0xcd,0xc4,0xdf,0xd6,
-0x31,0x38,0x23,0x2a,0x15,0x1c,0x07,0x0e,0x79,0x70,0x6b,0x62,0x5d,0x54,0x4f,0x46))
\ No newline at end of file
diff --git a/aespython/cbc_mode.py b/aespython/cbc_mode.py
deleted file mode 100644
index f55e647..0000000
--- a/aespython/cbc_mode.py
+++ /dev/null
@@ -1,65 +0,0 @@
-#!/usr/bin/env python
-"""
-CBC Mode of operation
-
-Running this file as __main__ will result in a self-test of the algorithm.
-
-Algorithm per NIST SP 800-38A http://csrc.nist.gov/publications/nistpubs/800-38a/sp800-38a.pdf
-
-Copyright (c) 2010, Adam Newman http://www.caller9.com/
-Licensed under the MIT license http://www.opensource.org/licenses/mit-license.php
-"""
-__author__ = "Adam Newman"
-
-class CBCMode:
- """Perform CBC operation on a block and retain IV information for next operation"""
- def __init__(self, block_cipher, block_size):
- self._block_cipher = block_cipher
- self._block_size = block_size
- self._iv = [0] * block_size
-
- def set_iv(self, iv):
- if len(iv) == self._block_size:
- self._iv = iv
-
- def encrypt_block(self, plaintext):
- iv=self._iv=self._block_cipher.cipher_block([i ^ j for i,j in zip (plaintext, self._iv)])
- return iv
-
- def decrypt_block(self, ciphertext):
- plaintext = list(self._block_cipher.decipher_block(ciphertext))
- for i,v in enumerate(self._iv):plaintext[i]^=v
- self._iv = ciphertext
- return plaintext
-
-import unittest
-class TestEncryptionMode(unittest.TestCase):
- def test_mode(self):
- #Self test
- import key_expander
- import aes_cipher
- import test_keys
-
- test_data = test_keys.TestKeys()
-
- test_expander = key_expander.KeyExpander(256)
- test_expanded_key = test_expander.expand(test_data.test_mode_key)
-
- test_cipher = aes_cipher.AESCipher(test_expanded_key)
-
- test_cbc = CBCMode(test_cipher, 16)
-
- test_cbc.set_iv(test_data.test_mode_iv)
- for k in range(4):
- self.assertEquals(len([i for i, j in zip(test_data.test_cbc_ciphertext[k],test_cbc.encrypt_block(test_data.test_mode_plaintext[k])) if i == j]),
- 16,
- msg='CBC encrypt test block %d'%k)
-
- test_cbc.set_iv(test_data.test_mode_iv)
- for k in range(4):
- self.assertEquals(len([i for i, j in zip(test_data.test_mode_plaintext[k],test_cbc.decrypt_block(test_data.test_cbc_ciphertext[k])) if i == j]),
- 16,
- msg='CBC decrypt test block %d'%k)
-
-if __name__ == "__main__":
- unittest.main()
\ No newline at end of file
diff --git a/aespython/cfb_mode.py b/aespython/cfb_mode.py
deleted file mode 100644
index 76e1971..0000000
--- a/aespython/cfb_mode.py
+++ /dev/null
@@ -1,65 +0,0 @@
-#!/usr/bin/env python
-"""
-CFB Mode of operation
-
-Running this file as __main__ will result in a self-test of the algorithm.
-
-Algorithm per NIST SP 800-38A http://csrc.nist.gov/publications/nistpubs/800-38a/sp800-38a.pdf
-
-Copyright (c) 2010, Adam Newman http://www.caller9.com/
-Licensed under the MIT license http://www.opensource.org/licenses/mit-license.php
-"""
-__author__ = "Adam Newman"
-
-class CFBMode:
- """Perform CFB operation on a block and retain IV information for next operation"""
- def __init__(self, block_cipher, block_size):
- self._block_cipher = block_cipher
- self._block_size = block_size
- self._iv = [0] * block_size
-
- def set_iv(self, iv):
- if len(iv) == self._block_size:
- self._iv = iv
-
- def encrypt_block(self, plaintext):
- cipher_iv = self._block_cipher.cipher_block(self._iv)
- iv = self._iv = [i ^ j for i,j in zip (plaintext, cipher_iv)]
- return iv
-
- def decrypt_block(self, ciphertext):
- cipher_iv = self._block_cipher.cipher_block(self._iv)
- self._iv = ciphertext
- return [i ^ j for i,j in zip (cipher_iv, ciphertext)]
-
-import unittest
-class TestEncryptionMode(unittest.TestCase):
- def test_mode(self):
- #Self test
- import key_expander
- import aes_cipher
- import test_keys
-
- test_data = test_keys.TestKeys()
-
- test_expander = key_expander.KeyExpander(256)
- test_expanded_key = test_expander.expand(test_data.test_mode_key)
-
- test_cipher = aes_cipher.AESCipher(test_expanded_key)
-
- test_cfb = CFBMode(test_cipher, 16)
-
- test_cfb.set_iv(test_data.test_mode_iv)
- for k in range(4):
- self.assertEquals(len([i for i, j in zip(test_data.test_cfb_ciphertext[k],test_cfb.encrypt_block(test_data.test_mode_plaintext[k])) if i == j]),
- 16,
- msg='CFB encrypt test block' + str(k))
-
- test_cfb.set_iv(test_data.test_mode_iv)
- for k in range(4):
- self.assertEquals(len([i for i, j in zip(test_data.test_mode_plaintext[k],test_cfb.decrypt_block(test_data.test_cfb_ciphertext[k])) if i == j]),
- 16,
- msg='CFB decrypt test block' + str(k))
-
-if __name__ == "__main__":
- unittest.main()
diff --git a/aespython/key_expander.py b/aespython/key_expander.py
deleted file mode 100644
index 0a20188..0000000
--- a/aespython/key_expander.py
+++ /dev/null
@@ -1,97 +0,0 @@
-#!/usr/bin/env python
-
-"""
-AES Key Expansion.
-
-Expands 128, 192, or 256 bit key for use with AES
-
-Running this file as __main__ will result in a self-test of the algorithm.
-
-Algorithm per NIST FIPS-197 http://csrc.nist.gov/publications/fips/fips197/fips-197.pdf
-
-Copyright (c) 2010, Adam Newman http://www.caller9.com/
-Licensed under the MIT license http://www.opensource.org/licenses/mit-license.php
-"""
-__author__ = "Adam Newman"
-
-#Normally use relative import. In test mode use local import.
-try:from .aes_tables import sbox,rcon
-except ValueError:from aes_tables import sbox,rcon
-from operator import xor
-class KeyExpander:
- """Perform AES Key Expansion"""
-
- _expanded_key_length = {128 : 176, 192 : 208, 256 : 240}
-
- def __init__(self, key_length):
- self._key_length = key_length
- self._n = key_length>>3
-
- if key_length in self._expanded_key_length:
- self._b = self._expanded_key_length[key_length]
- else:
- raise LookupError('Invalid Key Size')
-
- def expand(self, new_key):
- """
- Expand the encryption key per AES key schedule specifications
-
- http://en.wikipedia.org/wiki/Rijndael_key_schedule#Key_schedule_description
- """
- #First n bytes are copied from key
- len_new_key = len(new_key)
- if len_new_key != self._n:
- raise RuntimeError('expand(): key size is invalid')
- rcon_iter = 1
- nex=new_key.extend
-
- #Grow the key until it is the correct length
- while 1:
- #Copy last 4 bytes of extended key, apply core, increment i(rcon_iter),
- #core Append the list of elements 1-3 and list comprised of element 0 (circular rotate left)
- #core For each element of this new list, put the result of sbox into output array.
- #xor with 4 bytes n bytes from end of extended key
- keyarr=[sbox[i] for i in new_key[-3:]+new_key[-4:-3]]
- #First byte of output array is XORed with rcon(iter)
- keyarr[0] ^= rcon[rcon_iter]
- nex(map(xor,keyarr, new_key[-self._n:4-self._n]))
- rcon_iter += 1
- len_new_key += 4
-
- #Run three passes of 4 byte expansion using copy of 4 byte tail of extended key
- #which is then xor'd with 4 bytes n bytes from end of extended key
- for j in 0,1,2:
- nex(map(xor,new_key[-4:], new_key[-self._n:4-self._n]))
- len_new_key += 4
- if len_new_key >= self._b:return new_key
- else:
- #If key length is 256 and key is not complete, add 4 bytes tail of extended key
- #run through sbox before xor with 4 bytes n bytes from end of extended key
- if self._key_length == 256:
- nex(map(xor,[sbox[x] for x in new_key[-4:]], new_key[-self._n:4-self._n]))
- len_new_key += 4
- if len_new_key >= self._b:return new_key
-
- #If key length is 192 or 256 and key is not complete, run 2 or 3 passes respectively
- #of 4 byte tail of extended key xor with 4 bytes n bytes from end of extended key
- if self._key_length != 128:
- for j in ((0,1) if self._key_length == 192 else (0,1,2)):
- nex(map(xor,new_key[-4:], new_key[-self._n:4-self._n]))
- len_new_key += 4
- if len_new_key >= self._b:return new_key
-
-import unittest
-class TestKeyExpander(unittest.TestCase):
- def test_keys(self):
- """Test All Key Expansions"""
- import test_keys
- test_data = test_keys.TestKeys()
- for key_size in 128, 192, 256:
- test_expander = KeyExpander(key_size)
- test_expanded_key = test_expander.expand(test_data.test_key[key_size])
- self.assertEqual (len([i for i, j in zip(test_expanded_key, test_data.test_expanded_key_validated[key_size]) if i == j]),
- len(test_data.test_expanded_key_validated[key_size]),
- msg='Key expansion ' + str(key_size) + ' bit')
-
-if __name__ == "__main__":
- unittest.main()
\ No newline at end of file
diff --git a/aespython/ofb_mode.py b/aespython/ofb_mode.py
deleted file mode 100644
index 84d6048..0000000
--- a/aespython/ofb_mode.py
+++ /dev/null
@@ -1,63 +0,0 @@
-#!/usr/bin/env python
-"""
-OFB Mode of operation
-
-Running this file as __main__ will result in a self-test of the algorithm.
-
-Algorithm per NIST SP 800-38A http://csrc.nist.gov/publications/nistpubs/800-38a/sp800-38a.pdf
-
-Copyright (c) 2010, Adam Newman http://www.caller9.com/
-Licensed under the MIT license http://www.opensource.org/licenses/mit-license.php
-"""
-__author__ = "Adam Newman"
-
-class OFBMode:
- """Perform OFB operation on a block and retain IV information for next operation"""
- def __init__(self, block_cipher, block_size):
- self._block_cipher = block_cipher
- self._block_size = block_size
- self._iv = [0] * block_size
-
- def set_iv(self, iv):
- if len(iv) == self._block_size:
- self._iv = iv
-
- def encrypt_block(self, plaintext):
- self._iv = cipher_iv = self._block_cipher.cipher_block(self._iv)
- return [i ^ j for i,j in zip (plaintext, cipher_iv)]
-
- def decrypt_block(self, ciphertext):
- self._iv = cipher_iv = self._block_cipher.cipher_block(self._iv)
- return [i ^ j for i,j in zip (cipher_iv, ciphertext)]
-
-import unittest
-class TestEncryptionMode(unittest.TestCase):
- def test_mode(self):
- #Self test
- import key_expander
- import aes_cipher
- import test_keys
-
- test_data = test_keys.TestKeys()
-
- test_expander = key_expander.KeyExpander(256)
- test_expanded_key = test_expander.expand(test_data.test_mode_key)
-
- test_cipher = aes_cipher.AESCipher(test_expanded_key)
-
- test_ofb = OFBMode(test_cipher, 16)
-
- test_ofb.set_iv(test_data.test_mode_iv)
- for k in range(4):
- self.assertEquals(len([i for i, j in zip(test_data.test_ofb_ciphertext[k],test_ofb.encrypt_block(test_data.test_mode_plaintext[k])) if i == j]),
- 16,
- msg='OFB encrypt test block' + str(k))
-
- test_ofb.set_iv(test_data.test_mode_iv)
- for k in range(4):
- self.assertEquals(len([i for i, j in zip(test_data.test_mode_plaintext[k],test_ofb.decrypt_block(test_data.test_ofb_ciphertext[k])) if i == j]),
- 16,
- msg='OFB decrypt test block' + str(k))
-
-if __name__ == "__main__":
- unittest.main()
\ No newline at end of file
diff --git a/aespython/test_keys.py b/aespython/test_keys.py
deleted file mode 100644
index fb28286..0000000
--- a/aespython/test_keys.py
+++ /dev/null
@@ -1,119 +0,0 @@
-"""
-Test keys and data for self-test operations.
-
-Test data from:
-NIST SP 800-38A http://csrc.nist.gov/publications/nistpubs/800-38a/sp800-38a.pdf
-NIST FIPS-197 http://csrc.nist.gov/publications/fips/fips197/fips-197.pdf
-
-Copyright (c) 2010, Adam Newman http://www.caller9.com/
-Licensed under the MIT license http://www.opensource.org/licenses/mit-license.php
-"""
-__author__ = "Adam Newman"
-
-class TestKeys:
- """Test data, keys, IVs, and output to use in self-tests"""
- test_key = {
- 128 : [
- 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f]
- , 192 : [
- 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
- 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17]
- , 256 : [
- 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
- 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f]
- }
-
- test_expanded_key_validated = {
- 128 : [
- 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
- 0xd6, 0xaa, 0x74, 0xfd, 0xd2, 0xaf, 0x72, 0xfa, 0xda, 0xa6, 0x78, 0xf1, 0xd6, 0xab, 0x76, 0xfe,
- 0xb6, 0x92, 0xcf, 0x0b, 0x64, 0x3d, 0xbd, 0xf1, 0xbe, 0x9b, 0xc5, 0x00, 0x68, 0x30, 0xb3, 0xfe,
- 0xb6, 0xff, 0x74, 0x4e, 0xd2, 0xc2, 0xc9, 0xbf, 0x6c, 0x59, 0x0c, 0xbf, 0x04, 0x69, 0xbf, 0x41,
- 0x47, 0xf7, 0xf7, 0xbc, 0x95, 0x35, 0x3e, 0x03, 0xf9, 0x6c, 0x32, 0xbc, 0xfd, 0x05, 0x8d, 0xfd,
- 0x3c, 0xaa, 0xa3, 0xe8, 0xa9, 0x9f, 0x9d, 0xeb, 0x50, 0xf3, 0xaf, 0x57, 0xad, 0xf6, 0x22, 0xaa,
- 0x5e, 0x39, 0x0f, 0x7d, 0xf7, 0xa6, 0x92, 0x96, 0xa7, 0x55, 0x3d, 0xc1, 0x0a, 0xa3, 0x1f, 0x6b,
- 0x14, 0xf9, 0x70, 0x1a, 0xe3, 0x5f, 0xe2, 0x8c, 0x44, 0x0a, 0xdf, 0x4d, 0x4e, 0xa9, 0xc0, 0x26,
- 0x47, 0x43, 0x87, 0x35, 0xa4, 0x1c, 0x65, 0xb9, 0xe0, 0x16, 0xba, 0xf4, 0xae, 0xbf, 0x7a, 0xd2,
- 0x54, 0x99, 0x32, 0xd1, 0xf0, 0x85, 0x57, 0x68, 0x10, 0x93, 0xed, 0x9c, 0xbe, 0x2c, 0x97, 0x4e,
- 0x13, 0x11, 0x1d, 0x7f, 0xe3, 0x94, 0x4a, 0x17, 0xf3, 0x07, 0xa7, 0x8b, 0x4d, 0x2b, 0x30, 0xc5]
- , 192 : [
- 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
- 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x58, 0x46, 0xf2, 0xf9, 0x5c, 0x43, 0xf4, 0xfe,
- 0x54, 0x4a, 0xfe, 0xf5, 0x58, 0x47, 0xf0, 0xfa, 0x48, 0x56, 0xe2, 0xe9, 0x5c, 0x43, 0xf4, 0xfe,
- 0x40, 0xf9, 0x49, 0xb3, 0x1c, 0xba, 0xbd, 0x4d, 0x48, 0xf0, 0x43, 0xb8, 0x10, 0xb7, 0xb3, 0x42,
- 0x58, 0xe1, 0x51, 0xab, 0x04, 0xa2, 0xa5, 0x55, 0x7e, 0xff, 0xb5, 0x41, 0x62, 0x45, 0x08, 0x0c,
- 0x2a, 0xb5, 0x4b, 0xb4, 0x3a, 0x02, 0xf8, 0xf6, 0x62, 0xe3, 0xa9, 0x5d, 0x66, 0x41, 0x0c, 0x08,
- 0xf5, 0x01, 0x85, 0x72, 0x97, 0x44, 0x8d, 0x7e, 0xbd, 0xf1, 0xc6, 0xca, 0x87, 0xf3, 0x3e, 0x3c,
- 0xe5, 0x10, 0x97, 0x61, 0x83, 0x51, 0x9b, 0x69, 0x34, 0x15, 0x7c, 0x9e, 0xa3, 0x51, 0xf1, 0xe0,
- 0x1e, 0xa0, 0x37, 0x2a, 0x99, 0x53, 0x09, 0x16, 0x7c, 0x43, 0x9e, 0x77, 0xff, 0x12, 0x05, 0x1e,
- 0xdd, 0x7e, 0x0e, 0x88, 0x7e, 0x2f, 0xff, 0x68, 0x60, 0x8f, 0xc8, 0x42, 0xf9, 0xdc, 0xc1, 0x54,
- 0x85, 0x9f, 0x5f, 0x23, 0x7a, 0x8d, 0x5a, 0x3d, 0xc0, 0xc0, 0x29, 0x52, 0xbe, 0xef, 0xd6, 0x3a,
- 0xde, 0x60, 0x1e, 0x78, 0x27, 0xbc, 0xdf, 0x2c, 0xa2, 0x23, 0x80, 0x0f, 0xd8, 0xae, 0xda, 0x32,
- 0xa4, 0x97, 0x0a, 0x33, 0x1a, 0x78, 0xdc, 0x09, 0xc4, 0x18, 0xc2, 0x71, 0xe3, 0xa4, 0x1d, 0x5d]
- , 256 : [
- 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
- 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
- 0xa5, 0x73, 0xc2, 0x9f, 0xa1, 0x76, 0xc4, 0x98, 0xa9, 0x7f, 0xce, 0x93, 0xa5, 0x72, 0xc0, 0x9c,
- 0x16, 0x51, 0xa8, 0xcd, 0x02, 0x44, 0xbe, 0xda, 0x1a, 0x5d, 0xa4, 0xc1, 0x06, 0x40, 0xba, 0xde,
- 0xae, 0x87, 0xdf, 0xf0, 0x0f, 0xf1, 0x1b, 0x68, 0xa6, 0x8e, 0xd5, 0xfb, 0x03, 0xfc, 0x15, 0x67,
- 0x6d, 0xe1, 0xf1, 0x48, 0x6f, 0xa5, 0x4f, 0x92, 0x75, 0xf8, 0xeb, 0x53, 0x73, 0xb8, 0x51, 0x8d,
- 0xc6, 0x56, 0x82, 0x7f, 0xc9, 0xa7, 0x99, 0x17, 0x6f, 0x29, 0x4c, 0xec, 0x6c, 0xd5, 0x59, 0x8b,
- 0x3d, 0xe2, 0x3a, 0x75, 0x52, 0x47, 0x75, 0xe7, 0x27, 0xbf, 0x9e, 0xb4, 0x54, 0x07, 0xcf, 0x39,
- 0x0b, 0xdc, 0x90, 0x5f, 0xc2, 0x7b, 0x09, 0x48, 0xad, 0x52, 0x45, 0xa4, 0xc1, 0x87, 0x1c, 0x2f,
- 0x45, 0xf5, 0xa6, 0x60, 0x17, 0xb2, 0xd3, 0x87, 0x30, 0x0d, 0x4d, 0x33, 0x64, 0x0a, 0x82, 0x0a,
- 0x7c, 0xcf, 0xf7, 0x1c, 0xbe, 0xb4, 0xfe, 0x54, 0x13, 0xe6, 0xbb, 0xf0, 0xd2, 0x61, 0xa7, 0xdf,
- 0xf0, 0x1a, 0xfa, 0xfe, 0xe7, 0xa8, 0x29, 0x79, 0xd7, 0xa5, 0x64, 0x4a, 0xb3, 0xaf, 0xe6, 0x40,
- 0x25, 0x41, 0xfe, 0x71, 0x9b, 0xf5, 0x00, 0x25, 0x88, 0x13, 0xbb, 0xd5, 0x5a, 0x72, 0x1c, 0x0a,
- 0x4e, 0x5a, 0x66, 0x99, 0xa9, 0xf2, 0x4f, 0xe0, 0x7e, 0x57, 0x2b, 0xaa, 0xcd, 0xf8, 0xcd, 0xea,
- 0x24, 0xfc, 0x79, 0xcc, 0xbf, 0x09, 0x79, 0xe9, 0x37, 0x1a, 0xc2, 0x3c, 0x6d, 0x68, 0xde, 0x36]
- }
-
- test_block_ciphertext_validated = {
- 128 : [
- 0x69, 0xc4, 0xe0, 0xd8, 0x6a, 0x7b, 0x04, 0x30, 0xd8, 0xcd, 0xb7, 0x80, 0x70, 0xb4, 0xc5, 0x5a]
- , 192 : [
- 0xdd, 0xa9, 0x7c, 0xa4, 0x86, 0x4c, 0xdf, 0xe0, 0x6e, 0xaf, 0x70, 0xa0, 0xec, 0x0d, 0x71, 0x91]
- , 256 : [
- 0x8e, 0xa2, 0xb7, 0xca, 0x51, 0x67, 0x45, 0xbf, 0xea, 0xfc, 0x49, 0x90, 0x4b, 0x49, 0x60, 0x89]
- }
-
- test_block_plaintext = [
- 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff]
-
- #After initial validation, these deviated from test in SP 800-38A to use same key, iv, and plaintext on tests.
- #Still valid, just easier to test with.
- test_mode_key= [
- 0x60, 0x3d, 0xeb, 0x10, 0x15, 0xca, 0x71, 0xbe, 0x2b, 0x73, 0xae, 0xf0, 0x85, 0x7d, 0x77, 0x81,
- 0x1f, 0x35, 0x2c, 0x07, 0x3b, 0x61, 0x08, 0xd7, 0x2d, 0x98, 0x10, 0xa3, 0x09, 0x14, 0xdf, 0xf4]
- test_mode_iv = [
- 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f]
- test_mode_plaintext = [
- [0x6b, 0xc1, 0xbe, 0xe2, 0x2e, 0x40, 0x9f, 0x96, 0xe9, 0x3d, 0x7e, 0x11, 0x73, 0x93, 0x17, 0x2a],
- [0xae, 0x2d, 0x8a, 0x57, 0x1e, 0x03, 0xac, 0x9c, 0x9e, 0xb7, 0x6f, 0xac, 0x45, 0xaf, 0x8e, 0x51],
- [0x30, 0xc8, 0x1c, 0x46, 0xa3, 0x5c, 0xe4, 0x11, 0xe5, 0xfb, 0xc1, 0x19, 0x1a, 0x0a, 0x52, 0xef],
- [0xf6, 0x9f, 0x24, 0x45, 0xdf, 0x4f, 0x9b, 0x17, 0xad, 0x2b, 0x41, 0x7b, 0xe6, 0x6c, 0x37, 0x10]]
- test_cbc_ciphertext = [
- [0xf5, 0x8c, 0x4c, 0x04, 0xd6, 0xe5, 0xf1, 0xba, 0x77, 0x9e, 0xab, 0xfb, 0x5f, 0x7b, 0xfb, 0xd6],
- [0x9c, 0xfc, 0x4e, 0x96, 0x7e, 0xdb, 0x80, 0x8d, 0x67, 0x9f, 0x77, 0x7b, 0xc6, 0x70, 0x2c, 0x7d],
- [0x39, 0xf2, 0x33, 0x69, 0xa9, 0xd9, 0xba, 0xcf, 0xa5, 0x30, 0xe2, 0x63, 0x04, 0x23, 0x14, 0x61],
- [0xb2, 0xeb, 0x05, 0xe2, 0xc3, 0x9b, 0xe9, 0xfc, 0xda, 0x6c, 0x19, 0x07, 0x8c, 0x6a, 0x9d, 0x1b]]
- test_cfb_ciphertext = [
- [0xdc, 0x7e, 0x84, 0xbf, 0xda, 0x79, 0x16, 0x4b, 0x7e, 0xcd, 0x84, 0x86, 0x98, 0x5d, 0x38, 0x60],
- [0x39, 0xff, 0xed, 0x14, 0x3b, 0x28, 0xb1, 0xc8, 0x32, 0x11, 0x3c, 0x63, 0x31, 0xe5, 0x40, 0x7b],
- [0xdf, 0x10, 0x13, 0x24, 0x15, 0xe5, 0x4b, 0x92, 0xa1, 0x3e, 0xd0, 0xa8, 0x26, 0x7a, 0xe2, 0xf9],
- [0x75, 0xa3, 0x85, 0x74, 0x1a, 0xb9, 0xce, 0xf8, 0x20, 0x31, 0x62, 0x3d, 0x55, 0xb1, 0xe4, 0x71]]
- test_ofb_ciphertext = [
- [0xdc, 0x7e, 0x84, 0xbf, 0xda, 0x79, 0x16, 0x4b, 0x7e, 0xcd, 0x84, 0x86, 0x98, 0x5d, 0x38, 0x60],
- [0x4f, 0xeb, 0xdc, 0x67, 0x40, 0xd2, 0x0b, 0x3a, 0xc8, 0x8f, 0x6a, 0xd8, 0x2a, 0x4f, 0xb0, 0x8d],
- [0x71, 0xab, 0x47, 0xa0, 0x86, 0xe8, 0x6e, 0xed, 0xf3, 0x9d, 0x1c, 0x5b, 0xba, 0x97, 0xc4, 0x08],
- [0x01, 0x26, 0x14, 0x1d, 0x67, 0xf3, 0x7b, 0xe8, 0x53, 0x8f, 0x5a, 0x8b, 0xe7, 0x40, 0xe4, 0x84]]
-
- def hex_output(self, list):
- #Debugging output helper
- result = '['
- for i in list[:-1]:
- result += hex(i) + ','
- return result + hex(list[-1]) + ']'
-
-
-
\ No newline at end of file
diff --git a/colorama/PKG-INFO b/colorama/PKG-INFO
deleted file mode 100644
index 25ea42d..0000000
--- a/colorama/PKG-INFO
+++ /dev/null
@@ -1,330 +0,0 @@
-Metadata-Version: 1.0
-Name: colorama
-Version: 0.1.18
-Summary: Cross-platform colored terminal text.
-Home-page: http://code.google.com/p/colorama/
-Author: Jonathan Hartley
-Author-email: tartley@tartley.com
-License: BSD
-Description: Download and docs:
- http://pypi.python.org/pypi/colorama
- Development:
- http://code.google.com/p/colorama
-
- Description
- ===========
-
- Makes ANSI escape character sequences for producing colored terminal text work
- under MS Windows.
-
- ANSI escape character sequences have long been used to produce colored terminal
- text on Unix and Macs. Colorama makes this work on Windows, too. It also
- provides some shortcuts to help generate ANSI sequences, and works fine in
- conjunction with any other ANSI sequence generation library, such as Termcolor
- (http://pypi.python.org/pypi/termcolor.)
-
- This has the upshot of providing a simple cross-platform API for printing
- colored terminal text from Python, and has the happy side-effect that existing
- applications or libraries which use ANSI sequences to produce colored output on
- Linux or Macs can now also work on Windows, simply by calling
- ``colorama.init()``.
-
- A demo script in the source code repository prints some colored text using
- ANSI sequences. Compare its output under Gnome-terminal's built in ANSI
- handling, versus on Windows Command-Prompt using Colorama:
-
- .. image:: http://colorama.googlecode.com/hg/screenshots/ubuntu-demo.png
- :width: 661
- :height: 357
- :alt: ANSI sequences on Ubuntu under gnome-terminal.
-
- .. image:: http://colorama.googlecode.com/hg/screenshots/windows-demo.png
- :width: 668
- :height: 325
- :alt: Same ANSI sequences on Windows, using Colorama.
-
- These screengrabs make it clear that Colorama on Windows does not support
- ANSI 'dim text': it looks the same as 'normal text'.
-
-
- Dependencies
- ============
-
- None, other than Python. Tested on Python 2.5.5, 2.6.5, 2.7 & 3.1.2.
-
-
- Usage
- =====
-
- Initialisation
- --------------
-
- Applications should initialise Colorama using::
-
- from colorama import init
- init()
-
- If you are on Windows, the call to ``init()`` will start filtering ANSI escape
- sequences out of any text sent to stdout or stderr, and will replace them with
- equivalent Win32 calls.
-
- Calling ``init()`` has no effect on other platforms (unless you request other
- optional functionality, see keyword args below.) The intention is that
- applications can call ``init()`` unconditionally on all platforms, after which
- ANSI output should just work.
-
-
- Colored Output
- --------------
-
- Cross-platform printing of colored text can then be done using Colorama's
- constant shorthand for ANSI escape sequences::
-
- from colorama import Fore, Back, Style
- print Fore.RED + 'some red text'
- print Back.GREEN + and with a green background'
- print Style.DIM + 'and in dim text'
- print + Fore.RESET + Back.RESET + Style.RESET_ALL
- print 'back to normal now'
-
- or simply by manually printing ANSI sequences from your own code::
-
- print '/033[31m' + 'some red text'
- print '/033[30m' # and reset to default color
-
- or Colorama can be used happily in conjunction with existing ANSI libraries
- such as Termcolor::
-
- from colorama import init
- from termcolor import colored
-
- # use Colorama to make Termcolor work on Windows too
- init()
-
- # then use Termcolor for all colored text output
- print colored('Hello, World!', 'green', 'on_red')
-
- Available formatting constants are::
-
- Fore: BLACK, RED, GREEN, YELLOW, BLUE, MAGENTA, CYAN, WHITE, RESET.
- Back: BLACK, RED, GREEN, YELLOW, BLUE, MAGENTA, CYAN, WHITE, RESET.
- Style: DIM, NORMAL, BRIGHT, RESET_ALL
-
- Style.RESET_ALL resets foreground, background and brightness. Colorama will
- perform this reset automatically on program exit.
-
-
- Init Keyword Args
- -----------------
-
- ``init()`` accepts some kwargs to override default behaviour.
-
- init(autoreset=False):
- If you find yourself repeatedly sending reset sequences to turn off color
- changes at the end of every print, then ``init(autoreset=True)`` will
- automate that::
-
- from colorama import init
- init(autoreset=True)
- print Fore.RED + 'some red text'
- print 'automatically back to default color again'
-
- init(strip=None):
- Pass ``True`` or ``False`` to override whether ansi codes should be
- stripped from the output. The default behaviour is to strip if on Windows.
-
- init(convert=None):
- Pass ``True`` or ``False`` to override whether to convert ansi codes in the
- output into win32 calls. The default behaviour is to convert if on Windows
- and output is to a tty (terminal).
-
- init(wrap=True):
- On Windows, colorama works by replacing ``sys.stdout`` and ``sys.stderr``
- with proxy objects, which override the .write() method to do their work. If
- this wrapping causes you problems, then this can be disabled by passing
- ``init(wrap=False)``. The default behaviour is to wrap if autoreset or
- strip or convert are True.
-
- When wrapping is disabled, colored printing on non-Windows platforms will
- continue to work as normal. To do cross-platform colored output, you can
- use Colorama's ``AnsiToWin32`` proxy directly::
-
- from colorama import init, AnsiToWin32
- init(wrap=False)
- stream = AnsiToWin32(sys.stderr).stream
- print >>stream, Fore.BLUE + 'blue text on stderr'
-
-
- Status & Known Problems
- =======================
-
- Feature complete as far as colored text goes, but still finding bugs and
- occasionally making small changes to the API (such as new keyword arguments
- to ``init()``).
-
- Only tested on WinXP (CMD, Console2) and Ubuntu (gnome-terminal, xterm). Much
- obliged if anyone can let me know how it fares elsewhere, in particular on
- Macs.
-
- I'd like to add the ability to handle ANSI codes which position the text cursor
- and clear the terminal.
-
- See outstanding issues and wishlist at:
- http://code.google.com/p/colorama/issues/list
-
- If anything doesn't work for you, or doesn't do what you expected or hoped for,
- I'd *love* to hear about it on that issues list.
-
-
- Recognised ANSI Sequences
- =========================
-
- ANSI sequences generally take the form:
-
- ESC [ ; ...
-
- Where is an integer, and is a single letter. Zero or more
- params are passed to a . If no params are passed, it is generally
- synonymous with passing a single zero. No spaces exist in the sequence, they
- have just been inserted here to make it easy to read.
-
- The only ANSI sequences that colorama converts into win32 calls are::
-
- ESC [ 0 m # reset all (colors and brightness)
- ESC [ 1 m # bright
- ESC [ 2 m # dim (looks same as normal brightness)
- ESC [ 22 m # normal brightness
-
- # FOREGROUND:
- ESC [ 30 m # black
- ESC [ 31 m # red
- ESC [ 32 m # green
- ESC [ 33 m # yellow
- ESC [ 34 m # blue
- ESC [ 35 m # magenta
- ESC [ 36 m # cyan
- ESC [ 37 m # white
- ESC [ 39 m # reset
-
- # BACKGROUND
- ESC [ 40 m # black
- ESC [ 41 m # red
- ESC [ 42 m # green
- ESC [ 43 m # yellow
- ESC [ 44 m # blue
- ESC [ 45 m # magenta
- ESC [ 46 m # cyan
- ESC [ 47 m # white
- ESC [ 49 m # reset
-
- Multiple numeric params to the 'm' command can be combined into a single
- sequence, eg::
-
- ESC [ 36 ; 45 ; 1 m # bright cyan text on magenta background
-
- All other ANSI sequences of the form ``ESC [ ; ... ``
- are silently stripped from the output on Windows.
-
- Any other form of ANSI sequence, such as single-character codes or alternative
- initial characters, are not recognised nor stripped.
-
-
- Development
- ===========
-
- Running tests requires:
-
- - Michael Foord's 'mock' module to be installed.
- - Either to be run under Python2.7 or 3.1 stdlib unittest, or to have Michael
- Foord's 'unittest2' module to be installed.
-
- unittest2 test discovery doesn't work for colorama, so I use 'nose'::
-
- nosetests -s
-
- The -s is required because 'nosetests' otherwise applies a proxy of its own to
- stdout, which confuses the unit tests.
-
-
- Thanks
- ======
- Roger Binns, for many suggestions, valuable feedback, & bug reports.
- Tim Golden for thought and much appreciated feedback on the initial idea.
-
-
- Changes
- =======
-
- 0.1.17
- Prevent printing of garbage ANSI codes upon installing with pip
- 0.1.16
- Re-upload to fix previous error. Make clean now removes old MANIFEST.
- 0.1.15
- Completely broken. Distribution was empty due to leftover invalid MANIFEST
- file from building on a different platform.
- Fix python3 incompatibility kindly reported by G |uumlaut| nter Kolousek
- 0.1.14
- Fix hard-coded reset to white-on-black colors. Fore.RESET, Back.RESET
- and Style.RESET_ALL now revert to the colors as they were when init()
- was called. Some lessons hopefully learned about testing prior to release.
- 0.1.13
- Completely broken: barfed when installed using pip.
- 0.1.12
- Completely broken: contained no source code. double oops.
- 0.1.11
- Completely broken: fatal import errors on Ubuntu. oops.
- 0.1.10
- Stop emulating 'bright' text with bright backgrounds.
- Display 'normal' text using win32 normal foreground instead of bright.
- Drop support for 'dim' text.
- 0.1.9
- Fix incompatibility with Python 2.5 and earlier.
- Remove setup.py dependency on setuptools, now uses stdlib distutils.
- 0.1.8
- Fix ghastly errors all over the place on Ubuntu.
- Add init kwargs 'convert' and 'strip', which supercede the old 'wrap'.
- 0.1.7
- Python 3 compatible.
- Fix: Now strips ansi on windows without necessarily converting it to
- win32 calls (eg. if output is not a tty.)
- Fix: Flaky interaction of interleaved ansi sent to stdout and stderr.
- Improved demo.sh (hg checkout only.)
- 0.1.6
- Fix ansi sequences with no params now default to parmlist of [0].
- Fix flaky behaviour of autoreset and reset_all atexit.
- Fix stacking of repeated atexit calls - now just called once.
- Fix ghastly import problems while running tests.
- 'demo.py' (hg checkout only) now demonstrates autoreset and reset atexit.
- Provide colorama.VERSION, used by setup.py.
- Tests defanged so they no longer actually change terminal color when run.
- 0.1.5
- Now works on Ubuntu.
- 0.1.4
- Implemented RESET_ALL on application exit
- 0.1.3
- Implemented init(wrap=False)
- 0.1.2
- Implemented init(autoreset=True)
- 0.1.1
- Minor tidy
- 0.1
- Works on Windows for foreground color, background color, bright or dim
-
- .. |uumlaut| unicode:: U+00FC .. u with umlaut
- :trim:
-
-
-Keywords: color colour terminal text ansi windows crossplatform xplatform
-Platform: UNKNOWN
-Classifier: Development Status :: 2 - Pre-Alpha
-Classifier: Environment :: Console
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: BSD License
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 2
-Classifier: Programming Language :: Python :: 2.5
-Classifier: Programming Language :: Python :: 2.6
-Classifier: Programming Language :: Python :: 2.7
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.1
-Classifier: Topic :: Terminals
diff --git a/colorama/__init__.py b/colorama/__init__.py
deleted file mode 100644
index 331174e..0000000
--- a/colorama/__init__.py
+++ /dev/null
@@ -1,6 +0,0 @@
-from .initialise import init
-from .ansi import Fore, Back, Style
-from .ansitowin32 import AnsiToWin32
-
-VERSION = '0.1.18'
-
diff --git a/colorama/ansi.py b/colorama/ansi.py
deleted file mode 100644
index 7c45983..0000000
--- a/colorama/ansi.py
+++ /dev/null
@@ -1,49 +0,0 @@
-'''
-This module generates ANSI character codes to printing colors to terminals.
-See: http://en.wikipedia.org/wiki/ANSI_escape_code
-'''
-
-CSI = '\033['
-
-def code_to_chars(code):
- return CSI + str(code) + 'm'
-
-class AnsiCodes(object):
- def __init__(self, codes):
- for name in dir(codes):
- if not name.startswith('_'):
- value = getattr(codes, name)
- setattr(self, name, code_to_chars(value))
-
-class AnsiFore:
- BLACK = 30
- RED = 31
- GREEN = 32
- YELLOW = 33
- BLUE = 34
- MAGENTA = 35
- CYAN = 36
- WHITE = 37
- RESET = 39
-
-class AnsiBack:
- BLACK = 40
- RED = 41
- GREEN = 42
- YELLOW = 43
- BLUE = 44
- MAGENTA = 45
- CYAN = 46
- WHITE = 47
- RESET = 49
-
-class AnsiStyle:
- BRIGHT = 1
- DIM = 2
- NORMAL = 22
- RESET_ALL = 0
-
-Fore = AnsiCodes( AnsiFore )
-Back = AnsiCodes( AnsiBack )
-Style = AnsiCodes( AnsiStyle )
-
diff --git a/colorama/ansitowin32.py b/colorama/ansitowin32.py
deleted file mode 100644
index 363061d..0000000
--- a/colorama/ansitowin32.py
+++ /dev/null
@@ -1,176 +0,0 @@
-
-import re
-import sys
-
-from .ansi import AnsiFore, AnsiBack, AnsiStyle, Style
-from .winterm import WinTerm, WinColor, WinStyle
-from .win32 import windll
-
-
-if windll is not None:
- winterm = WinTerm()
-
-
-def is_a_tty(stream):
- return hasattr(stream, 'isatty') and stream.isatty()
-
-
-class StreamWrapper(object):
- '''
- Wraps a stream (such as stdout), acting as a transparent proxy for all
- attribute access apart from method 'write()', which is delegated to our
- Converter instance.
- '''
- def __init__(self, wrapped, converter):
- # double-underscore everything to prevent clashes with names of
- # attributes on the wrapped stream object.
- self.__wrapped = wrapped
- self.__convertor = converter
-
- def __getattr__(self, name):
- return getattr(self.__wrapped, name)
-
- def write(self, text):
- self.__convertor.write(text)
-
-
-class AnsiToWin32(object):
- '''
- Implements a 'write()' method which, on Windows, will strip ANSI character
- sequences from the text, and if outputting to a tty, will convert them into
- win32 function calls.
- '''
- ANSI_RE = re.compile('\033\[((?:\d|;)*)([a-zA-Z])')
-
- def __init__(self, wrapped, convert=None, strip=None, autoreset=False):
- # The wrapped stream (normally sys.stdout or sys.stderr)
- self.wrapped = wrapped
-
- # should we reset colors to defaults after every .write()
- self.autoreset = autoreset
-
- # create the proxy wrapping our output stream
- self.stream = StreamWrapper(wrapped, self)
-
- on_windows = sys.platform.startswith('win')
-
- # should we strip ANSI sequences from our output?
- if strip is None:
- strip = on_windows
- self.strip = strip
-
- # should we should convert ANSI sequences into win32 calls?
- if convert is None:
- convert = on_windows and is_a_tty(wrapped)
- self.convert = convert
-
- # dict of ansi codes to win32 functions and parameters
- self.win32_calls = self.get_win32_calls()
-
- # are we wrapping stderr?
- self.on_stderr = self.wrapped is sys.stderr
-
-
- def should_wrap(self):
- '''
- True if this class is actually needed. If false, then the output
- stream will not be affected, nor will win32 calls be issued, so
- wrapping stdout is not actually required. This will generally be
- False on non-Windows platforms, unless optional functionality like
- autoreset has been requested using kwargs to init()
- '''
- return self.convert or self.strip or self.autoreset
-
-
- def get_win32_calls(self):
- if self.convert and winterm:
- return {
- AnsiStyle.RESET_ALL: (winterm.reset_all, ),
- AnsiStyle.BRIGHT: (winterm.style, WinStyle.BRIGHT),
- AnsiStyle.DIM: (winterm.style, WinStyle.NORMAL),
- AnsiStyle.NORMAL: (winterm.style, WinStyle.NORMAL),
- AnsiFore.BLACK: (winterm.fore, WinColor.BLACK),
- AnsiFore.RED: (winterm.fore, WinColor.RED),
- AnsiFore.GREEN: (winterm.fore, WinColor.GREEN),
- AnsiFore.YELLOW: (winterm.fore, WinColor.YELLOW),
- AnsiFore.BLUE: (winterm.fore, WinColor.BLUE),
- AnsiFore.MAGENTA: (winterm.fore, WinColor.MAGENTA),
- AnsiFore.CYAN: (winterm.fore, WinColor.CYAN),
- AnsiFore.WHITE: (winterm.fore, WinColor.GREY),
- AnsiFore.RESET: (winterm.fore, ),
- AnsiBack.BLACK: (winterm.back, WinColor.BLACK),
- AnsiBack.RED: (winterm.back, WinColor.RED),
- AnsiBack.GREEN: (winterm.back, WinColor.GREEN),
- AnsiBack.YELLOW: (winterm.back, WinColor.YELLOW),
- AnsiBack.BLUE: (winterm.back, WinColor.BLUE),
- AnsiBack.MAGENTA: (winterm.back, WinColor.MAGENTA),
- AnsiBack.CYAN: (winterm.back, WinColor.CYAN),
- AnsiBack.WHITE: (winterm.back, WinColor.GREY),
- AnsiBack.RESET: (winterm.back, ),
- }
-
-
- def write(self, text):
- if self.strip or self.convert:
- self.write_and_convert(text)
- else:
- self.wrapped.write(text)
- self.wrapped.flush()
- if self.autoreset:
- self.reset_all()
-
-
- def reset_all(self):
- if self.convert:
- self.call_win32('m', (0,))
- else:
- self.wrapped.write(Style.RESET_ALL)
-
-
- def write_and_convert(self, text):
- '''
- Write the given text to our wrapped stream, stripping any ANSI
- sequences from the text, and optionally converting them into win32
- calls.
- '''
- cursor = 0
- for match in self.ANSI_RE.finditer(text):
- start, end = match.span()
- self.write_plain_text(text, cursor, start)
- self.convert_ansi(*match.groups())
- cursor = end
- self.write_plain_text(text, cursor, len(text))
-
-
- def write_plain_text(self, text, start, end):
- if start < end:
- self.wrapped.write(text[start:end])
- self.wrapped.flush()
-
-
- def convert_ansi(self, paramstring, command):
- if self.convert:
- params = self.extract_params(paramstring)
- self.call_win32(command, params)
-
-
- def extract_params(self, paramstring):
- def split(paramstring):
- for p in paramstring.split(';'):
- if p != '':
- yield int(p)
- return tuple(split(paramstring))
-
-
- def call_win32(self, command, params):
- if params == []:
- params = [0]
- if command == 'm':
- for param in params:
- if param in self.win32_calls:
- func_args = self.win32_calls[param]
- func = func_args[0]
- args = func_args[1:]
- kwargs = dict(on_stderr=self.on_stderr)
- func(*args, **kwargs)
-
diff --git a/colorama/initialise.py b/colorama/initialise.py
deleted file mode 100644
index 4df5c3e..0000000
--- a/colorama/initialise.py
+++ /dev/null
@@ -1,38 +0,0 @@
-import atexit
-import sys
-
-from .ansitowin32 import AnsiToWin32
-
-
-orig_stdout = sys.stdout
-orig_stderr = sys.stderr
-
-atexit_done = False
-
-
-def reset_all():
- AnsiToWin32(orig_stdout).reset_all()
-
-
-def init(autoreset=False, convert=None, strip=None, wrap=True):
-
- if wrap==False and (autoreset==True or convert==True or strip==True):
- raise ValueError('wrap=False conflicts with any other arg=True')
-
- sys.stdout = wrap_stream(orig_stdout, convert, strip, autoreset, wrap)
- sys.stderr = wrap_stream(orig_stderr, convert, strip, autoreset, wrap)
-
- global atexit_done
- if not atexit_done:
- atexit.register(reset_all)
- atexit_done = True
-
-
-def wrap_stream(stream, convert, strip, autoreset, wrap):
- if wrap:
- wrapper = AnsiToWin32(stream,
- convert=convert, strip=strip, autoreset=autoreset)
- if wrapper.should_wrap():
- stream = wrapper.stream
- return stream
-
diff --git a/colorama/win32.py b/colorama/win32.py
deleted file mode 100644
index 2a6fc94..0000000
--- a/colorama/win32.py
+++ /dev/null
@@ -1,95 +0,0 @@
-
-# from winbase.h
-STDOUT = -11
-STDERR = -12
-
-try:
- from ctypes import windll
-except ImportError:
- windll = None
- SetConsoleTextAttribute = lambda *_: None
-else:
- from ctypes import (
- byref, Structure, c_char, c_short, c_uint32, c_ushort
- )
-
- handles = {
- STDOUT: windll.kernel32.GetStdHandle(STDOUT),
- STDERR: windll.kernel32.GetStdHandle(STDERR),
- }
-
- SHORT = c_short
- WORD = c_ushort
- DWORD = c_uint32
- TCHAR = c_char
-
- class COORD(Structure):
- """struct in wincon.h"""
- _fields_ = [
- ('X', SHORT),
- ('Y', SHORT),
- ]
-
- class SMALL_RECT(Structure):
- """struct in wincon.h."""
- _fields_ = [
- ("Left", SHORT),
- ("Top", SHORT),
- ("Right", SHORT),
- ("Bottom", SHORT),
- ]
-
- class CONSOLE_SCREEN_BUFFER_INFO(Structure):
- """struct in wincon.h."""
- _fields_ = [
- ("dwSize", COORD),
- ("dwCursorPosition", COORD),
- ("wAttributes", WORD),
- ("srWindow", SMALL_RECT),
- ("dwMaximumWindowSize", COORD),
- ]
-
- def GetConsoleScreenBufferInfo(stream_id):
- handle = handles[stream_id]
- csbi = CONSOLE_SCREEN_BUFFER_INFO()
- success = windll.kernel32.GetConsoleScreenBufferInfo(
- handle, byref(csbi))
- # This fails when imported via setup.py when installing using 'pip'
- # presumably the fix is that running setup.py should not trigger all
- # this activity.
- # assert success
- return csbi
-
- def SetConsoleTextAttribute(stream_id, attrs):
- handle = handles[stream_id]
- success = windll.kernel32.SetConsoleTextAttribute(handle, attrs)
- assert success
-
- def SetConsoleCursorPosition(stream_id, position):
- handle = handles[stream_id]
- position = COORD(*position)
- success = windll.kernel32.SetConsoleCursorPosition(handle, position)
- assert success
-
- def FillConsoleOutputCharacter(stream_id, char, length, start):
- handle = handles[stream_id]
- char = TCHAR(char)
- length = DWORD(length)
- start = COORD(*start)
- num_written = DWORD(0)
- # AttributeError: function 'FillConsoleOutputCharacter' not found
- # could it just be that my types are wrong?
- success = windll.kernel32.FillConsoleOutputCharacter(
- handle, char, length, start, byref(num_written))
- assert success
- return num_written.value
-
-
-if __name__=='__main__':
- x = GetConsoleScreenBufferInfo(STDOUT)
- print(x.dwSize)
- print(x.dwCursorPosition)
- print(x.wAttributes)
- print(x.srWindow)
- print(x.dwMaximumWindowSize)
-
diff --git a/colorama/winterm.py b/colorama/winterm.py
deleted file mode 100644
index 4326c21..0000000
--- a/colorama/winterm.py
+++ /dev/null
@@ -1,69 +0,0 @@
-
-from . import win32
-
-
-# from wincon.h
-class WinColor(object):
- BLACK = 0
- BLUE = 1
- GREEN = 2
- CYAN = 3
- RED = 4
- MAGENTA = 5
- YELLOW = 6
- GREY = 7
-
-# from wincon.h
-class WinStyle(object):
- NORMAL = 0x00 # dim text, dim background
- BRIGHT = 0x08 # bright text, dim background
-
-
-class WinTerm(object):
-
- def __init__(self):
- self._default = \
- win32.GetConsoleScreenBufferInfo(win32.STDOUT).wAttributes
- self.set_attrs(self._default)
- self._default_fore = self._fore
- self._default_back = self._back
- self._default_style = self._style
-
- def get_attrs(self):
- return self._fore + self._back * 16 + self._style
-
- def set_attrs(self, value):
- self._fore = value & 7
- self._back = (value >> 4) & 7
- self._style = value & WinStyle.BRIGHT
-
- def reset_all(self, on_stderr=None):
- self.set_attrs(self._default)
- self.set_console(attrs=self._default)
-
- def fore(self, fore=None, on_stderr=False):
- if fore is None:
- fore = self._default_fore
- self._fore = fore
- self.set_console(on_stderr=on_stderr)
-
- def back(self, back=None, on_stderr=False):
- if back is None:
- back = self._default_back
- self._back = back
- self.set_console(on_stderr=on_stderr)
-
- def style(self, style=None, on_stderr=False):
- if style is None:
- style = self._default_style
- self._style = style
- self.set_console(on_stderr=on_stderr)
-
- def set_console(self, attrs=None, on_stderr=False):
- if attrs is None:
- attrs = self.get_attrs()
- handle = win32.STDOUT
- if on_stderr:
- handle = win32.STDERR
- win32.SetConsoleTextAttribute(handle, attrs)
-
diff --git a/jsbeautifier/__init__.py b/jsbeautifier/__init__.py
deleted file mode 100644
index 18353f4..0000000
--- a/jsbeautifier/__init__.py
+++ /dev/null
@@ -1,1128 +0,0 @@
-import sys
-import getopt
-import re
-import string
-
-#
-# Originally written by Einar Lielmanis et al.,
-# Conversion to python by Einar Lielmanis, einar@jsbeautifier.org,
-# MIT licence, enjoy.
-#
-# Python is not my native language, feel free to push things around.
-#
-# Use either from command line (script displays its usage when run
-# without any parameters),
-#
-#
-# or, alternatively, use it as a module:
-#
-# import jsbeautifier
-# res = jsbeautifier.beautify('your javascript string')
-# res = jsbeautifier.beautify_file('some_file.js')
-#
-# you may specify some options:
-#
-# opts = jsbeautifier.default_options()
-# opts.indent_size = 2
-# res = jsbeautifier.beautify('some javascript', opts)
-#
-#
-# Here are the available options: (read source)
-
-
-class BeautifierOptions:
- def __init__(self):
- self.indent_size = 4
- self.indent_char = ' '
- self.indent_with_tabs = False
- self.preserve_newlines = True
- self.max_preserve_newlines = 10.
- self.jslint_happy = False
- self.brace_style = 'collapse'
- self.keep_array_indentation = False
- self.keep_function_indentation = False
- self.eval_code = False
-
-
-
- def __repr__(self):
- return \
-"""indent_size = %d
-indent_char = [%s]
-preserve_newlines = %s
-max_preserve_newlines = %d
-jslint_happy = %s
-indent_with_tabs = %s
-brace_style = %s
-keep_array_indentation = %s
-eval_code = %s
-""" % ( self.indent_size,
- self.indent_char,
- self.preserve_newlines,
- self.max_preserve_newlines,
- self.jslint_happy,
- self.indent_with_tabs,
- self.brace_style,
- self.keep_array_indentation,
- self.eval_code,
- )
-
-
-class BeautifierFlags:
- def __init__(self, mode):
- self.previous_mode = 'BLOCK'
- self.mode = mode
- self.var_line = False
- self.var_line_tainted = False
- self.var_line_reindented = False
- self.in_html_comment = False
- self.if_line = False
- self.in_case = False
- self.eat_next_space = False
- self.indentation_baseline = -1
- self.indentation_level = 0
- self.ternary_depth = 0
-
-
-def default_options():
- return BeautifierOptions()
-
-
-def beautify(string, opts = default_options() ):
- b = Beautifier()
- return b.beautify(string, opts)
-
-
-def beautify_file(file_name, opts = default_options() ):
-
- if file_name == '-': # stdin
- f = sys.stdin
- else:
- f = open(file_name)
-
- b = Beautifier()
- return b.beautify(''.join(f.readlines()), opts)
-
-
-def usage():
-
- print("""Javascript beautifier (http://jsbeautifier.org/)
-
-Usage: jsbeautifier.py [options]
-
- can be "-", which means stdin.
- defaults to stdout
-
-Input options:
-
- -i, --stdin read input from stdin
-
-Output options:
-
- -s, --indent-size=NUMBER indentation size. (default 4).
- -c, --indent-char=CHAR character to indent with. (default space).
- -t, --indent-with-tabs Indent with tabs, overrides -s and -c
- -d, --disable-preserve-newlines do not preserve existing line breaks.
- -j, --jslint-happy more jslint-compatible output
- -b, --brace-style=collapse brace style (collapse, expand, end-expand)
- -k, --keep-array-indentation keep array indentation.
- -o, --outfile=FILE specify a file to output to (default stdout)
- -f, --keep-function-indentation Do not re-indent function bodies defined in var lines.
-
-Rarely needed options:
-
- --eval-code evaluate code if a JS interpreter is
- installed. May be useful with some obfuscated
- script but poses a potential security issue.
-
- -l, --indent-level=NUMBER initial indentation level. (default 0).
-
- -h, --help, --usage prints this help statement.
-
-""");
-
-
-
-
-
-
-class Beautifier:
-
- def __init__(self, opts = default_options() ):
-
- self.opts = opts
- self.blank_state()
-
- def blank_state(self):
-
- # internal flags
- self.flags = BeautifierFlags('BLOCK')
- self.flag_store = []
- self.wanted_newline = False
- self.just_added_newline = False
- self.do_block_just_closed = False
-
- if self.opts.indent_with_tabs:
- self.indent_string = "\t"
- else:
- self.indent_string = self.opts.indent_char * self.opts.indent_size
-
- self.preindent_string = ''
- self.last_word = '' # last TK_WORD seen
- self.last_type = 'TK_START_EXPR' # last token type
- self.last_text = '' # last token text
- self.last_last_text = '' # pre-last token text
-
- self.input = None
- self.output = [] # formatted javascript gets built here
-
- self.whitespace = ["\n", "\r", "\t", " "]
- self.wordchar = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_$'
- self.digits = '0123456789'
- self.punct = '+ - * / % & ++ -- = += -= *= /= %= == === != !== > < >= <= >> << >>> >>>= >>= <<= && &= | || ! !! , : ? ^ ^= |= ::'
- self.punct += ' <%= <% %>'
- self.punct = self.punct.split(' ')
-
-
- # Words which always should start on a new line
- self.line_starters = 'continue,try,throw,return,var,if,switch,case,default,for,while,break,function'.split(',')
- self.set_mode('BLOCK')
-
- global parser_pos
- parser_pos = 0
-
-
- def beautify(self, s, opts = None ):
-
- if opts != None:
- self.opts = opts
-
-
- if self.opts.brace_style not in ['expand', 'collapse', 'end-expand']:
- raise(Exception('opts.brace_style must be "expand", "collapse" or "end-expand".'))
-
- self.blank_state()
-
- while s and s[0] in [' ', '\t']:
- self.preindent_string += s[0]
- s = s[1:]
-
- self.input = self.unpack(s, opts.eval_code)
-
- parser_pos = 0
- while True:
- token_text, token_type = self.get_next_token()
- #print (token_text, token_type, self.flags.mode)
- if token_type == 'TK_EOF':
- break
-
- handlers = {
- 'TK_START_EXPR': self.handle_start_expr,
- 'TK_END_EXPR': self.handle_end_expr,
- 'TK_START_BLOCK': self.handle_start_block,
- 'TK_END_BLOCK': self.handle_end_block,
- 'TK_WORD': self.handle_word,
- 'TK_SEMICOLON': self.handle_semicolon,
- 'TK_STRING': self.handle_string,
- 'TK_EQUALS': self.handle_equals,
- 'TK_OPERATOR': self.handle_operator,
- 'TK_BLOCK_COMMENT': self.handle_block_comment,
- 'TK_INLINE_COMMENT': self.handle_inline_comment,
- 'TK_COMMENT': self.handle_comment,
- 'TK_UNKNOWN': self.handle_unknown,
- }
-
- handlers[token_type](token_text)
-
- self.last_last_text = self.last_text
- self.last_type = token_type
- self.last_text = token_text
-
- sweet_code = self.preindent_string + re.sub('[\n ]+$', '', ''.join(self.output))
- return sweet_code
-
- def unpack(self, source, evalcode=False):
- import jsbeautifier.unpackers as unpackers
- try:
- return unpackers.run(source, evalcode)
- except unpackers.UnpackingError as error:
- print('error:', error)
- return ''
-
- def trim_output(self, eat_newlines = False):
- while len(self.output) \
- and (
- self.output[-1] == ' '\
- or self.output[-1] == self.indent_string \
- or self.output[-1] == self.preindent_string \
- or (eat_newlines and self.output[-1] in ['\n', '\r'])):
- self.output.pop()
-
-
- def is_array(self, mode):
- return mode in ['[EXPRESSION]', '[INDENDED-EXPRESSION]']
-
-
- def is_expression(self, mode):
- return mode in ['[EXPRESSION]', '[INDENDED-EXPRESSION]', '(EXPRESSION)']
-
-
- def append_newline_forced(self):
- old_array_indentation = self.opts.keep_array_indentation
- self.opts.keep_array_indentation = False
- self.append_newline()
- self.opts.keep_array_indentation = old_array_indentation
-
- def append_newline(self, ignore_repeated = True):
-
- self.flags.eat_next_space = False;
-
- if self.opts.keep_array_indentation and self.is_array(self.flags.mode):
- return
-
- self.flags.if_line = False;
- self.trim_output();
-
- if len(self.output) == 0:
- # no newline on start of file
- return
-
- if self.output[-1] != '\n' or not ignore_repeated:
- self.just_added_newline = True
- self.output.append('\n')
-
- if self.preindent_string:
- self.output.append(self.preindent_string)
-
- for i in range(self.flags.indentation_level):
- self.output.append(self.indent_string)
-
- if self.flags.var_line and self.flags.var_line_reindented:
- self.output.append(self.indent_string)
-
-
- def append(self, s):
- if s == ' ':
- # make sure only single space gets drawn
- if self.flags.eat_next_space:
- self.flags.eat_next_space = False
- elif len(self.output) and self.output[-1] not in [' ', '\n', self.indent_string]:
- self.output.append(' ')
- else:
- self.just_added_newline = False
- self.flags.eat_next_space = False
- self.output.append(s)
-
-
- def indent(self):
- self.flags.indentation_level = self.flags.indentation_level + 1
-
-
- def remove_indent(self):
- if len(self.output) and self.output[-1] in [self.indent_string, self.preindent_string]:
- self.output.pop()
-
-
- def set_mode(self, mode):
-
- prev = BeautifierFlags('BLOCK')
-
- if self.flags:
- self.flag_store.append(self.flags)
- prev = self.flags
-
- self.flags = BeautifierFlags(mode)
-
- if len(self.flag_store) == 1:
- self.flags.indentation_level = 0
- else:
- self.flags.indentation_level = prev.indentation_level
- if prev.var_line and prev.var_line_reindented:
- self.flags.indentation_level = self.flags.indentation_level + 1
- self.flags.previous_mode = prev.mode
-
-
- def restore_mode(self):
- self.do_block_just_closed = self.flags.mode == 'DO_BLOCK'
- if len(self.flag_store) > 0:
- self.flags = self.flag_store.pop()
-
-
- def get_next_token(self):
-
- global parser_pos
-
- self.n_newlines = 0
-
- if parser_pos >= len(self.input):
- return '', 'TK_EOF'
-
- self.wanted_newline = False;
- c = self.input[parser_pos]
- parser_pos += 1
-
- keep_whitespace = self.opts.keep_array_indentation and self.is_array(self.flags.mode)
-
- if keep_whitespace:
- # slight mess to allow nice preservation of array indentation and reindent that correctly
- # first time when we get to the arrays:
- # var a = [
- # ....'something'
- # we make note of whitespace_count = 4 into flags.indentation_baseline
- # so we know that 4 whitespaces in original source match indent_level of reindented source
- #
- # and afterwards, when we get to
- # 'something,
- # .......'something else'
- # we know that this should be indented to indent_level + (7 - indentation_baseline) spaces
-
- whitespace_count = 0
- while c in self.whitespace:
- if c == '\n':
- self.trim_output()
- self.output.append('\n')
- self.just_added_newline = True
- whitespace_count = 0
- elif c == '\t':
- whitespace_count += 4
- elif c == '\r':
- pass
- else:
- whitespace_count += 1
-
- if parser_pos >= len(self.input):
- return '', 'TK_EOF'
-
- c = self.input[parser_pos]
- parser_pos += 1
-
- if self.flags.indentation_baseline == -1:
-
- self.flags.indentation_baseline = whitespace_count
-
- if self.just_added_newline:
- for i in range(self.flags.indentation_level + 1):
- self.output.append(self.indent_string)
-
- if self.flags.indentation_baseline != -1:
- for i in range(whitespace_count - self.flags.indentation_baseline):
- self.output.append(' ')
-
- else: # not keep_whitespace
- while c in self.whitespace:
- if c == '\n':
- if self.opts.max_preserve_newlines == 0 or self.opts.max_preserve_newlines > self.n_newlines:
- self.n_newlines += 1
-
- if parser_pos >= len(self.input):
- return '', 'TK_EOF'
-
- c = self.input[parser_pos]
- parser_pos += 1
-
- if self.opts.preserve_newlines and self.n_newlines > 1:
- for i in range(self.n_newlines):
- self.append_newline(i == 0)
- self.just_added_newline = True
-
- self.wanted_newline = self.n_newlines > 0
-
-
- if c in self.wordchar:
- if parser_pos < len(self.input):
- while self.input[parser_pos] in self.wordchar:
- c = c + self.input[parser_pos]
- parser_pos += 1
- if parser_pos == len(self.input):
- break
-
- # small and surprisingly unugly hack for 1E-10 representation
- if parser_pos != len(self.input) and self.input[parser_pos] in '+-' \
- and re.match('^[0-9]+[Ee]$', c):
-
- sign = self.input[parser_pos]
- parser_pos += 1
- t = self.get_next_token()
- c += sign + t[0]
- return c, 'TK_WORD'
-
- if c == 'in': # in is an operator, need to hack
- return c, 'TK_OPERATOR'
-
- if self.wanted_newline and \
- self.last_type != 'TK_OPERATOR' and\
- self.last_type != 'TK_EQUALS' and\
- not self.flags.if_line and \
- (self.opts.preserve_newlines or self.last_text != 'var'):
- self.append_newline()
-
- return c, 'TK_WORD'
-
- if c in '([':
- return c, 'TK_START_EXPR'
-
- if c in ')]':
- return c, 'TK_END_EXPR'
-
- if c == '{':
- return c, 'TK_START_BLOCK'
-
- if c == '}':
- return c, 'TK_END_BLOCK'
-
- if c == ';':
- return c, 'TK_SEMICOLON'
-
- if c == '/':
- comment = ''
- inline_comment = True
- comment_mode = 'TK_INLINE_COMMENT'
- if self.input[parser_pos] == '*': # peek /* .. */ comment
- parser_pos += 1
- if parser_pos < len(self.input):
- while not (self.input[parser_pos] == '*' and \
- parser_pos + 1 < len(self.input) and \
- self.input[parser_pos + 1] == '/')\
- and parser_pos < len(self.input):
- c = self.input[parser_pos]
- comment += c
- if c in '\r\n':
- comment_mode = 'TK_BLOCK_COMMENT'
- parser_pos += 1
- if parser_pos >= len(self.input):
- break
- parser_pos += 2
- return '/*' + comment + '*/', comment_mode
- if self.input[parser_pos] == '/': # peek // comment
- comment = c
- while self.input[parser_pos] not in '\r\n':
- comment += self.input[parser_pos]
- parser_pos += 1
- if parser_pos >= len(self.input):
- break
- parser_pos += 1
- if self.wanted_newline:
- self.append_newline()
- return comment, 'TK_COMMENT'
-
-
-
- if c == "'" or c == '"' or \
- (c == '/' and ((self.last_type == 'TK_WORD' and self.last_text in ['return', 'do']) or \
- (self.last_type in ['TK_COMMENT', 'TK_START_EXPR', 'TK_START_BLOCK', 'TK_END_BLOCK', 'TK_OPERATOR',
- 'TK_EQUALS', 'TK_EOF', 'TK_SEMICOLON']))):
- sep = c
- esc = False
- resulting_string = c
- in_char_class = False
-
- if parser_pos < len(self.input):
- if sep == '/':
- # handle regexp
- in_char_class = False
- while esc or in_char_class or self.input[parser_pos] != sep:
- resulting_string += self.input[parser_pos]
- if not esc:
- esc = self.input[parser_pos] == '\\'
- if self.input[parser_pos] == '[':
- in_char_class = True
- elif self.input[parser_pos] == ']':
- in_char_class = False
- else:
- esc = False
- parser_pos += 1
- if parser_pos >= len(self.input):
- # incomplete regex when end-of-file reached
- # bail out with what has received so far
- return resulting_string, 'TK_STRING'
- else:
- # handle string
- while esc or self.input[parser_pos] != sep:
- resulting_string += self.input[parser_pos]
- if not esc:
- esc = self.input[parser_pos] == '\\'
- else:
- esc = False
- parser_pos += 1
- if parser_pos >= len(self.input):
- # incomplete string when end-of-file reached
- # bail out with what has received so far
- return resulting_string, 'TK_STRING'
-
-
- parser_pos += 1
- resulting_string += sep
- if sep == '/':
- # regexps may have modifiers /regexp/MOD, so fetch those too
- while parser_pos < len(self.input) and self.input[parser_pos] in self.wordchar:
- resulting_string += self.input[parser_pos]
- parser_pos += 1
- return resulting_string, 'TK_STRING'
-
- if c == '#':
-
- # she-bang
- if len(self.output) == 0 and len(self.input) > 1 and self.input[parser_pos] == '!':
- resulting_string = c
- while parser_pos < len(self.input) and c != '\n':
- c = self.input[parser_pos]
- resulting_string += c
- parser_pos += 1
- self.output.append(resulting_string.strip() + "\n")
- self.append_newline()
- return self.get_next_token()
-
-
- # Spidermonkey-specific sharp variables for circular references
- # https://developer.mozilla.org/En/Sharp_variables_in_JavaScript
- # http://mxr.mozilla.org/mozilla-central/source/js/src/jsscan.cpp around line 1935
- sharp = '#'
- if parser_pos < len(self.input) and self.input[parser_pos] in self.digits:
- while True:
- c = self.input[parser_pos]
- sharp += c
- parser_pos += 1
- if parser_pos >= len(self.input) or c == '#' or c == '=':
- break
- if c == '#' or parser_pos >= len(self.input):
- pass
- elif self.input[parser_pos] == '[' and self.input[parser_pos + 1] == ']':
- sharp += '[]'
- parser_pos += 2
- elif self.input[parser_pos] == '{' and self.input[parser_pos + 1] == '}':
- sharp += '{}'
- parser_pos += 2
- return sharp, 'TK_WORD'
-
- if c == '<' and self.input[parser_pos - 1 : parser_pos + 3] == '':
- self.flags.in_html_comment = False
- parser_pos += 2
- if self.wanted_newline:
- self.append_newline()
- return '-->', 'TK_COMMENT'
-
- if c in self.punct:
- while parser_pos < len(self.input) and c + self.input[parser_pos] in self.punct:
- c += self.input[parser_pos]
- parser_pos += 1
- if parser_pos >= len(self.input):
- break
- if c == '=':
- return c, 'TK_EQUALS'
- else:
- return c, 'TK_OPERATOR'
- return c, 'TK_UNKNOWN'
-
-
-
- def handle_start_expr(self, token_text):
- if token_text == '[':
- if self.last_type == 'TK_WORD' or self.last_text == ')':
- if self.last_text in self.line_starters:
- self.append(' ')
- self.set_mode('(EXPRESSION)')
- self.append(token_text)
- return
-
- if self.flags.mode in ['[EXPRESSION]', '[INDENTED-EXPRESSION]']:
- if self.last_last_text == ']' and self.last_text == ',':
- # ], [ goes to a new line
- if self.flags.mode == '[EXPRESSION]':
- self.flags.mode = '[INDENTED-EXPRESSION]'
- if not self.opts.keep_array_indentation:
- self.indent()
- self.set_mode('[EXPRESSION]')
- if not self.opts.keep_array_indentation:
- self.append_newline()
- elif self.last_text == '[':
- if self.flags.mode == '[EXPRESSION]':
- self.flags.mode = '[INDENTED-EXPRESSION]'
- if not self.opts.keep_array_indentation:
- self.indent()
- self.set_mode('[EXPRESSION]')
-
- if not self.opts.keep_array_indentation:
- self.append_newline()
- else:
- self.set_mode('[EXPRESSION]')
- else:
- self.set_mode('[EXPRESSION]')
- else:
- self.set_mode('(EXPRESSION)')
-
-
- if self.last_text == ';' or self.last_type == 'TK_START_BLOCK':
- self.append_newline()
- elif self.last_type in ['TK_END_EXPR', 'TK_START_EXPR', 'TK_END_BLOCK'] or self.last_text == '.':
- # do nothing on (( and )( and ][ and ]( and .(
- pass
- elif self.last_type not in ['TK_WORD', 'TK_OPERATOR']:
- self.append(' ')
- elif self.last_word == 'function' or self.last_word == 'typeof':
- # function() vs function (), typeof() vs typeof ()
- if self.opts.jslint_happy:
- self.append(' ')
- elif self.last_text in self.line_starters or self.last_text == 'catch':
- self.append(' ')
-
- self.append(token_text)
-
-
- def handle_end_expr(self, token_text):
- if token_text == ']':
- if self.opts.keep_array_indentation:
- if self.last_text == '}':
- self.remove_indent()
- self.append(token_text)
- self.restore_mode()
- return
- else:
- if self.flags.mode == '[INDENTED-EXPRESSION]':
- if self.last_text == ']':
- self.restore_mode()
- self.append_newline()
- self.append(token_text)
- return
- self.restore_mode()
- self.append(token_text)
-
-
- def handle_start_block(self, token_text):
- if self.last_word == 'do':
- self.set_mode('DO_BLOCK')
- else:
- self.set_mode('BLOCK')
-
- if self.opts.brace_style == 'expand':
- if self.last_type != 'TK_OPERATOR':
- if self.last_text in ['return', '=']:
- self.append(' ')
- else:
- self.append_newline(True)
-
- self.append(token_text)
- self.indent()
- else:
- if self.last_type not in ['TK_OPERATOR', 'TK_START_EXPR']:
- if self.last_type == 'TK_START_BLOCK':
- self.append_newline()
- else:
- self.append(' ')
- else:
- # if TK_OPERATOR or TK_START_EXPR
- if self.is_array(self.flags.previous_mode) and self.last_text == ',':
- if self.last_last_text == '}':
- self.append(' ')
- else:
- self.append_newline()
- self.indent()
- self.append(token_text)
-
-
- def handle_end_block(self, token_text):
- self.restore_mode()
- if self.opts.brace_style == 'expand':
- if self.last_text != '{':
- self.append_newline()
- else:
- if self.last_type == 'TK_START_BLOCK':
- if self.just_added_newline:
- self.remove_indent()
- else:
- # {}
- self.trim_output()
- else:
- if self.is_array(self.flags.mode) and self.opts.keep_array_indentation:
- self.opts.keep_array_indentation = False
- self.append_newline()
- self.opts.keep_array_indentation = True
- else:
- self.append_newline()
-
- self.append(token_text)
-
-
- def handle_word(self, token_text):
- if self.do_block_just_closed:
- self.append(' ')
- self.append(token_text)
- self.append(' ')
- self.do_block_just_closed = False
- return
-
- if token_text == 'function':
-
- if self.flags.var_line:
- self.flags.var_line_reindented = not self.opts.keep_function_indentation
- if (self.just_added_newline or self.last_text == ';') and self.last_text != '{':
- # make sure there is a nice clean space of at least one blank line
- # before a new function definition
- have_newlines = self.n_newlines
- if not self.just_added_newline:
- have_newlines = 0
- if not self.opts.preserve_newlines:
- have_newlines = 1
- for i in range(2 - have_newlines):
- self.append_newline(False)
-
- if token_text in ['case', 'default']:
- if self.last_text == ':':
- self.remove_indent()
- else:
- self.flags.indentation_level -= 1
- self.append_newline()
- self.flags.indentation_level += 1
- self.append(token_text)
- self.flags.in_case = True
- return
-
- prefix = 'NONE'
-
- if self.last_type == 'TK_END_BLOCK':
- if token_text not in ['else', 'catch', 'finally']:
- prefix = 'NEWLINE'
- else:
- if self.opts.brace_style in ['expand', 'end-expand']:
- prefix = 'NEWLINE'
- else:
- prefix = 'SPACE'
- self.append(' ')
- elif self.last_type == 'TK_SEMICOLON' and self.flags.mode in ['BLOCK', 'DO_BLOCK']:
- prefix = 'NEWLINE'
- elif self.last_type == 'TK_SEMICOLON' and self.is_expression(self.flags.mode):
- prefix = 'SPACE'
- elif self.last_type == 'TK_STRING':
- prefix = 'NEWLINE'
- elif self.last_type == 'TK_WORD':
- if self.last_text == 'else':
- # eat newlines between ...else *** some_op...
- # won't preserve extra newlines in this place (if any), but don't care that much
- self.trim_output(True);
- prefix = 'SPACE'
- elif self.last_type == 'TK_START_BLOCK':
- prefix = 'NEWLINE'
- elif self.last_type == 'TK_END_EXPR':
- self.append(' ')
- prefix = 'NEWLINE'
-
- if self.flags.if_line and self.last_type == 'TK_END_EXPR':
- self.flags.if_line = False
-
- if token_text in self.line_starters:
- if self.last_text == 'else':
- prefix = 'SPACE'
- else:
- prefix = 'NEWLINE'
-
- if token_text in ['else', 'catch', 'finally']:
- if self.last_type != 'TK_END_BLOCK' \
- or self.opts.brace_style == 'expand' \
- or self.opts.brace_style == 'end-expand':
- self.append_newline()
- else:
- self.trim_output(True)
- self.append(' ')
- elif prefix == 'NEWLINE':
- if token_text == 'function' and (self.last_type == 'TK_START_EXPR' or self.last_text in '=,'):
- # no need to force newline on "function" -
- # (function...
- pass
- elif token_text == 'function' and self.last_text == 'new':
- self.append(' ')
- elif self.last_text in ['return', 'throw']:
- # no newline between return nnn
- self.append(' ')
- elif self.last_type != 'TK_END_EXPR':
- if (self.last_type != 'TK_START_EXPR' or token_text != 'var') and self.last_text != ':':
- # no need to force newline on VAR -
- # for (var x = 0...
- if token_text == 'if' and self.last_word == 'else' and self.last_text != '{':
- self.append(' ')
- else:
- self.flags.var_line = False
- self.flags.var_line_reindented = False
- self.append_newline()
- elif token_text in self.line_starters and self.last_text != ')':
- self.flags.var_line = False
- self.flags.var_line_reindented = False
- self.append_newline()
- elif self.is_array(self.flags.mode) and self.last_text == ',' and self.last_last_text == '}':
- self.append_newline() # }, in lists get a newline
- elif prefix == 'SPACE':
- self.append(' ')
-
-
- self.append(token_text)
- self.last_word = token_text
-
- if token_text == 'var':
- self.flags.var_line = True
- self.flags.var_line_reindented = False
- self.flags.var_line_tainted = False
-
-
- if token_text == 'if':
- self.flags.if_line = True
-
- if token_text == 'else':
- self.flags.if_line = False
-
-
- def handle_semicolon(self, token_text):
- self.append(token_text)
- self.flags.var_line = False
- self.flags.var_line_reindented = False
- if self.flags.mode == 'OBJECT':
- # OBJECT mode is weird and doesn't get reset too well.
- self.flags.mode = 'BLOCK'
-
-
- def handle_string(self, token_text):
- if self.last_type in ['TK_START_BLOCK', 'TK_END_BLOCK', 'TK_SEMICOLON']:
- self.append_newline()
- elif self.last_type == 'TK_WORD':
- self.append(' ')
-
- # Try to replace readable \x-encoded characters with their equivalent,
- # if it is possible (e.g. '\x41\x42\x43\x01' becomes 'ABC\x01').
- def unescape(match):
- block, code = match.group(0, 1)
- char = chr(int(code, 16))
- if block.count('\\') == 1 and char in string.printable:
- return char
- return block
-
- token_text = re.sub(r'\\{1,2}x([a-fA-F0-9]{2})', unescape, token_text)
-
- self.append(token_text)
-
- def handle_equals(self, token_text):
- if self.flags.var_line:
- # just got an '=' in a var-line, different line breaking rules will apply
- self.flags.var_line_tainted = True
-
- self.append(' ')
- self.append(token_text)
- self.append(' ')
-
-
- def handle_operator(self, token_text):
- space_before = True
- space_after = True
-
- if self.flags.var_line and token_text == ',' and self.is_expression(self.flags.mode):
- # do not break on comma, for ( var a = 1, b = 2
- self.flags.var_line_tainted = False
-
- if self.flags.var_line and token_text == ',':
- if self.flags.var_line_tainted:
- self.append(token_text)
- self.flags.var_line_reindented = True
- self.flags.var_line_tainted = False
- self.append_newline()
- return
- else:
- self.flags.var_line_tainted = False
-
- if self.last_text in ['return', 'throw']:
- # return had a special handling in TK_WORD
- self.append(' ')
- self.append(token_text)
- return
-
- if token_text == ':' and self.flags.in_case:
- self.append(token_text)
- self.append_newline()
- self.flags.in_case = False
- return
-
- if token_text == '::':
- # no spaces around the exotic namespacing syntax operator
- self.append(token_text)
- return
-
- if token_text == ',':
- if self.flags.var_line:
- if self.flags.var_line_tainted:
- # This never happens, as it's handled previously, right?
- self.append(token_text)
- self.append_newline()
- self.flags.var_line_tainted = False
- else:
- self.append(token_text)
- self.append(' ')
- elif self.last_type == 'TK_END_BLOCK' and self.flags.mode != '(EXPRESSION)':
- self.append(token_text)
- if self.flags.mode == 'OBJECT' and self.last_text == '}':
- self.append_newline()
- else:
- self.append(' ')
- else:
- if self.flags.mode == 'OBJECT':
- self.append(token_text)
- self.append_newline()
- else:
- # EXPR or DO_BLOCK
- self.append(token_text)
- self.append(' ')
- # comma handled
- return
- elif token_text in ['--', '++', '!'] \
- or (token_text in ['+', '-'] \
- and self.last_type in ['TK_START_BLOCK', 'TK_START_EXPR', 'TK_EQUALS', 'TK_OPERATOR']) \
- or self.last_text in self.line_starters:
-
- space_before = False
- space_after = False
-
- if self.last_text == ';' and self.is_expression(self.flags.mode):
- # for (;; ++i)
- # ^^
- space_before = True
-
- if self.last_type == 'TK_WORD' and self.last_text in self.line_starters:
- space_before = True
-
- if self.flags.mode == 'BLOCK' and self.last_text in ['{', ';']:
- # { foo: --i }
- # foo(): --bar
- self.append_newline()
-
- elif token_text == '.':
- # decimal digits or object.property
- space_before = False
-
- elif token_text == ':':
- if self.flags.ternary_depth == 0:
- self.flags.mode = 'OBJECT'
- space_before = False
- else:
- self.flags.ternary_depth -= 1
- elif token_text == '?':
- self.flags.ternary_depth += 1
-
- if space_before:
- self.append(' ')
-
- self.append(token_text)
-
- if space_after:
- self.append(' ')
-
-
-
- def handle_block_comment(self, token_text):
-
- lines = token_text.replace('\x0d', '').split('\x0a')
- # all lines start with an asterisk? that's a proper box comment
- if not any(l for l in lines[1:] if ( l.strip() == '' or (l.lstrip())[0] != '*')):
- self.append_newline()
- self.append(lines[0])
- for line in lines[1:]:
- self.append_newline()
- self.append(' ' + line.strip())
- else:
- # simple block comment: leave intact
- if len(lines) > 1:
- # multiline comment starts on a new line
- self.append_newline()
- self.trim_output()
- else:
- # single line /* ... */ comment stays on the same line
- self.append(' ')
- for line in lines:
- self.append(line)
- self.append('\n')
- self.append_newline()
-
-
- def handle_inline_comment(self, token_text):
- self.append(' ')
- self.append(token_text)
- if self.is_expression(self.flags.mode):
- self.append(' ')
- else:
- self.append_newline_forced()
-
-
- def handle_comment(self, token_text):
- if self.wanted_newline:
- self.append_newline()
- else:
- self.append(' ')
-
- self.append(token_text)
- self.append_newline_forced()
-
-
- def handle_unknown(self, token_text):
- if self.last_text in ['return', 'throw']:
- self.append(' ')
-
- self.append(token_text)
-
-
-
-
-
-def main():
-
- argv = sys.argv[1:]
-
- try:
- opts, args = getopt.getopt(argv, "s:c:o:djbkil:h:t:f", ['indent-size=','indent-char=','outfile=', 'disable-preserve-newlines',
- 'jslint-happy', 'brace-style=',
- 'keep-array-indentation', 'indent-level=', 'help',
- 'usage', 'stdin', 'eval-code', 'indent-with-tabs', 'keep-function-indentation'])
- except getopt.GetoptError:
- usage()
- sys.exit(2)
-
- js_options = default_options()
-
- file = None
- outfile = 'stdout'
- if len(args) == 1:
- file = args[0]
-
- for opt, arg in opts:
- if opt in ('--keep-array-indentation', '-k'):
- js_options.keep_array_indentation = True
- if opt in ('--keep-function-indentation','-f'):
- js_options.keep_function_indentation = True
- elif opt in ('--outfile', '-o'):
- outfile = arg
- elif opt in ('--indent-size', '-s'):
- js_options.indent_size = int(arg)
- elif opt in ('--indent-char', '-c'):
- js_options.indent_char = arg
- elif opt in ('--indent-with-tabs', '-t'):
- js_options.indent_with_tabs = True
- elif opt in ('--disable-preserve_newlines', '-d'):
- js_options.preserve_newlines = False
- elif opt in ('--jslint-happy', '-j'):
- js_options.jslint_happy = True
- elif opt in ('--eval-code'):
- js_options.eval_code = True
- elif opt in ('--brace-style', '-b'):
- js_options.brace_style = arg
- elif opt in ('--stdin', '-i'):
- file = '-'
- elif opt in ('--help', '--usage', '--h'):
- return usage()
-
- if not file:
- return usage()
- else:
- if outfile == 'stdout':
- print(beautify_file(file, js_options))
- else:
- f = open(outfile, 'w')
- f.write(beautify_file(file, js_options) + '\n')
- f.close()
-
diff --git a/jsbeautifier/unpackers/README.specs.mkd b/jsbeautifier/unpackers/README.specs.mkd
deleted file mode 100644
index e937b76..0000000
--- a/jsbeautifier/unpackers/README.specs.mkd
+++ /dev/null
@@ -1,25 +0,0 @@
-# UNPACKERS SPECIFICATIONS
-
-Nothing very difficult: an unpacker is a submodule placed in the directory
-where this file was found. Each unpacker must define three symbols:
-
- * `PRIORITY` : integer number expressing the priority in applying this
- unpacker. Lower number means higher priority.
- Makes sense only if a source file has been packed with
- more than one packer.
- * `detect(source)` : returns `True` if source is packed, otherwise, `False`.
- * `unpack(source)` : takes a `source` string and unpacks it. Must always return
- valid JavaScript. That is to say, your code should look
- like:
-
-```
-if detect(source):
- return do_your_fancy_things_with(source)
-else:
- return source
-```
-
-*You can safely define any other symbol in your module, as it will be ignored.*
-
-`__init__` code will automatically load new unpackers, without any further step
-to be accomplished. Simply drop it in this directory.
diff --git a/jsbeautifier/unpackers/__init__.py b/jsbeautifier/unpackers/__init__.py
deleted file mode 100644
index 6d13653..0000000
--- a/jsbeautifier/unpackers/__init__.py
+++ /dev/null
@@ -1,67 +0,0 @@
-#
-# General code for JSBeautifier unpackers infrastructure. See README.specs
-# written by Stefano Sanfilippo
-#
-
-"""General code for JSBeautifier unpackers infrastructure."""
-
-import pkgutil
-import re
-from jsbeautifier.unpackers import evalbased
-
-# NOTE: AT THE MOMENT, IT IS DEACTIVATED FOR YOUR SECURITY: it runs js!
-BLACKLIST = ['jsbeautifier.unpackers.evalbased']
-
-class UnpackingError(Exception):
- """Badly packed source or general error. Argument is a
- meaningful description."""
- pass
-
-def getunpackers():
- """Scans the unpackers dir, finds unpackers and add them to UNPACKERS list.
- An unpacker will be loaded only if it is a valid python module (name must
- adhere to naming conventions) and it is not blacklisted (i.e. inserted
- into BLACKLIST."""
- path = __path__
- prefix = __name__ + '.'
- unpackers = []
- interface = ['unpack', 'detect', 'PRIORITY']
- for _importer, modname, _ispkg in pkgutil.iter_modules(path, prefix):
- if 'tests' not in modname and modname not in BLACKLIST:
- try:
- module = __import__(modname, fromlist=interface)
- except ImportError:
- raise UnpackingError('Bad unpacker: %s' % modname)
- else:
- unpackers.append(module)
-
- return sorted(unpackers, key = lambda mod: mod.PRIORITY)
-
-UNPACKERS = getunpackers()
-
-def run(source, evalcode=False):
- """Runs the applicable unpackers and return unpacked source as a string."""
- for unpacker in [mod for mod in UNPACKERS if mod.detect(source)]:
- source = unpacker.unpack(source)
- if evalcode and evalbased.detect(source):
- source = evalbased.unpack(source)
- return source
-
-def filtercomments(source):
- """NOT USED: strips trailing comments and put them at the top."""
- trailing_comments = []
- comment = True
-
- while comment:
- if re.search(r'^\s*\/\*', source):
- comment = source[0, source.index('*/') + 2]
- elif re.search(r'^\s*\/\/', source):
- comment = re.search(r'^\s*\/\/', source).group(0)
- else:
- comment = None
-
- if comment:
- source = re.sub(r'^\s+', '', source[len(comment):])
- trailing_comments.append(comment)
-
- return '\n'.join(trailing_comments) + source
diff --git a/jsbeautifier/unpackers/evalbased.py b/jsbeautifier/unpackers/evalbased.py
deleted file mode 100644
index b17d926..0000000
--- a/jsbeautifier/unpackers/evalbased.py
+++ /dev/null
@@ -1,39 +0,0 @@
-#
-# Unpacker for eval() based packers, a part of javascript beautifier
-# by Einar Lielmanis
-#
-# written by Stefano Sanfilippo
-#
-# usage:
-#
-# if detect(some_string):
-# unpacked = unpack(some_string)
-#
-
-"""Unpacker for eval() based packers: runs JS code and returns result.
-Works only if a JS interpreter (e.g. Mozilla's Rhino) is installed and
-properly set up on host."""
-
-from subprocess import PIPE, Popen
-
-PRIORITY = 3
-
-def detect(source):
- """Detects if source is likely to be eval() packed."""
- return source.strip().lower().startswith('eval(function(')
-
-def unpack(source):
- """Runs source and return resulting code."""
- return jseval('print %s;' % source[4:]) if detect(source) else source
-
-# In case of failure, we'll just return the original, without crashing on user.
-def jseval(script):
- """Run code in the JS interpreter and return output."""
- try:
- interpreter = Popen(['js'], stdin=PIPE, stdout=PIPE)
- except OSError:
- return script
- result, errors = interpreter.communicate(script)
- if interpreter.poll() or errors:
- return script
- return result
diff --git a/jsbeautifier/unpackers/javascriptobfuscator.py b/jsbeautifier/unpackers/javascriptobfuscator.py
deleted file mode 100644
index aa4344a..0000000
--- a/jsbeautifier/unpackers/javascriptobfuscator.py
+++ /dev/null
@@ -1,58 +0,0 @@
-#
-# simple unpacker/deobfuscator for scripts messed up with
-# javascriptobfuscator.com
-#
-# written by Einar Lielmanis
-# rewritten in Python by Stefano Sanfilippo
-#
-# Will always return valid javascript: if `detect()` is false, `code` is
-# returned, unmodified.
-#
-# usage:
-#
-# if javascriptobfuscator.detect(some_string):
-# some_string = javascriptobfuscator.unpack(some_string)
-#
-
-"""deobfuscator for scripts messed up with JavascriptObfuscator.com"""
-
-import re
-
-PRIORITY = 1
-
-def smartsplit(code):
- """Split `code` at " symbol, only if it is not escaped."""
- strings = []
- pos = 0
- while pos < len(code):
- if code[pos] == '"':
- word = '' # new word
- pos += 1
- while pos < len(code):
- if code[pos] == '"':
- break
- if code[pos] == '\\':
- word += '\\'
- pos += 1
- word += code[pos]
- pos += 1
- strings.append('"%s"' % word)
- pos += 1
- return strings
-
-def detect(code):
- """Detects if `code` is JavascriptObfuscator.com packed."""
- # prefer `is not` idiom, so that a true boolean is returned
- return (re.search(r'^var _0x[a-f0-9]+ ?\= ?\[', code) is not None)
-
-def unpack(code):
- """Unpacks JavascriptObfuscator.com packed code."""
- if detect(code):
- matches = re.search(r'var (_0x[a-f\d]+) ?\= ?\[(.*?)\];', code)
- if matches:
- variable = matches.group(1)
- dictionary = smartsplit(matches.group(2))
- code = code[len(matches.group(0)):]
- for key, value in enumerate(dictionary):
- code = code.replace(r'%s[%s]' % (variable, key), value)
- return code
diff --git a/jsbeautifier/unpackers/myobfuscate.py b/jsbeautifier/unpackers/myobfuscate.py
deleted file mode 100644
index 52e1003..0000000
--- a/jsbeautifier/unpackers/myobfuscate.py
+++ /dev/null
@@ -1,86 +0,0 @@
-#
-# deobfuscator for scripts messed up with myobfuscate.com
-# by Einar Lielmanis
-#
-# written by Stefano Sanfilippo
-#
-# usage:
-#
-# if detect(some_string):
-# unpacked = unpack(some_string)
-#
-
-# CAVEAT by Einar Lielmanis
-
-#
-# You really don't want to obfuscate your scripts there: they're tracking
-# your unpackings, your script gets turned into something like this,
-# as of 2011-08-26:
-#
-# var _escape = 'your_script_escaped';
-# var _111 = document.createElement('script');
-# _111.src = 'http://api.www.myobfuscate.com/?getsrc=ok' +
-# '&ref=' + encodeURIComponent(document.referrer) +
-# '&url=' + encodeURIComponent(document.URL);
-# var 000 = document.getElementsByTagName('head')[0];
-# 000.appendChild(_111);
-# document.write(unescape(_escape));
-#
-
-"""Deobfuscator for scripts messed up with MyObfuscate.com"""
-
-import re
-import base64
-
-# Python 2 retrocompatibility
-# pylint: disable=F0401
-# pylint: disable=E0611
-try:
- from urllib import unquote
-except ImportError:
- from urllib.parse import unquote
-
-from jsbeautifier.unpackers import UnpackingError
-
-PRIORITY = 1
-
-CAVEAT = """//
-// Unpacker warning: be careful when using myobfuscate.com for your projects:
-// scripts obfuscated by the free online version call back home.
-//
-
-"""
-
-SIGNATURE = (r'["\x41\x42\x43\x44\x45\x46\x47\x48\x49\x4A\x4B\x4C\x4D\x4E\x4F'
- r'\x50\x51\x52\x53\x54\x55\x56\x57\x58\x59\x5A\x61\x62\x63\x64\x65'
- r'\x66\x67\x68\x69\x6A\x6B\x6C\x6D\x6E\x6F\x70\x71\x72\x73\x74\x75'
- r'\x76\x77\x78\x79\x7A\x30\x31\x32\x33\x34\x35\x36\x37\x38\x39\x2B'
- r'\x2F\x3D","","\x63\x68\x61\x72\x41\x74","\x69\x6E\x64\x65\x78'
- r'\x4F\x66","\x66\x72\x6F\x6D\x43\x68\x61\x72\x43\x6F\x64\x65","'
- r'\x6C\x65\x6E\x67\x74\x68"]')
-
-def detect(source):
- """Detects MyObfuscate.com packer."""
- return SIGNATURE in source
-
-def unpack(source):
- """Unpacks js code packed with MyObfuscate.com"""
- if not detect(source):
- return source
- payload = unquote(_filter(source))
- match = re.search(r"^var _escape\='