1/* 2 * aes.js: implements AES - Advanced Encryption Standard 3 * from the SlowAES project, http://code.google.com/p/slowaes/ 4 * 5 * Copyright (c) 2008 Josh Davis ( http://www.josh-davis.org ), 6 * Mark Percival ( http://mpercival.com ), 7 * 8 * Ported from C code written by Laurent Haan ( http://www.progressive-coding.com ) 9 * 10 * Licensed under the Apache License, Version 2.0 11 * http://www.apache.org/licenses/ 12 */ 13 14var slowAES = { 15 /* 16 * START AES SECTION 17 */ 18 aes:{ 19 // structure of valid key sizes 20 keySize:{ 21 SIZE_128:16, 22 SIZE_192:24, 23 SIZE_256:32 24 }, 25 26 // Rijndael S-box 27 sbox:[ 28 0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76, 29 0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0, 30 0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15, 31 0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75, 32 0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, 0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84, 33 0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf, 34 0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8, 35 0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, 0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2, 36 0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73, 37 0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb, 38 0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, 0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79, 39 0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08, 40 0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a, 41 0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e, 42 0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf, 43 0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16 ], 44 45 // Rijndael Inverted S-box 46 rsbox: 47 [ 0x52, 0x09, 0x6a, 0xd5, 0x30, 0x36, 0xa5, 0x38, 0xbf, 0x40, 0xa3, 0x9e, 0x81, 0xf3, 0xd7, 0xfb 48 , 0x7c, 0xe3, 0x39, 0x82, 0x9b, 0x2f, 0xff, 0x87, 0x34, 0x8e, 0x43, 0x44, 0xc4, 0xde, 0xe9, 0xcb 49 , 0x54, 0x7b, 0x94, 0x32, 0xa6, 0xc2, 0x23, 0x3d, 0xee, 0x4c, 0x95, 0x0b, 0x42, 0xfa, 0xc3, 0x4e 50 , 0x08, 0x2e, 0xa1, 0x66, 0x28, 0xd9, 0x24, 0xb2, 0x76, 0x5b, 0xa2, 0x49, 0x6d, 0x8b, 0xd1, 0x25 51 , 0x72, 0xf8, 0xf6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xd4, 0xa4, 0x5c, 0xcc, 0x5d, 0x65, 0xb6, 0x92 52 , 0x6c, 0x70, 0x48, 0x50, 0xfd, 0xed, 0xb9, 0xda, 0x5e, 0x15, 0x46, 0x57, 0xa7, 0x8d, 0x9d, 0x84 53 , 0x90, 0xd8, 0xab, 0x00, 0x8c, 0xbc, 0xd3, 0x0a, 0xf7, 0xe4, 0x58, 0x05, 0xb8, 0xb3, 0x45, 0x06 54 , 0xd0, 0x2c, 0x1e, 0x8f, 0xca, 0x3f, 0x0f, 0x02, 0xc1, 0xaf, 0xbd, 0x03, 0x01, 0x13, 0x8a, 0x6b 55 , 0x3a, 0x91, 0x11, 0x41, 0x4f, 0x67, 0xdc, 0xea, 0x97, 0xf2, 0xcf, 0xce, 0xf0, 0xb4, 0xe6, 0x73 56 , 0x96, 0xac, 0x74, 0x22, 0xe7, 0xad, 0x35, 0x85, 0xe2, 0xf9, 0x37, 0xe8, 0x1c, 0x75, 0xdf, 0x6e 57 , 0x47, 0xf1, 0x1a, 0x71, 0x1d, 0x29, 0xc5, 0x89, 0x6f, 0xb7, 0x62, 0x0e, 0xaa, 0x18, 0xbe, 0x1b 58 , 0xfc, 0x56, 0x3e, 0x4b, 0xc6, 0xd2, 0x79, 0x20, 0x9a, 0xdb, 0xc0, 0xfe, 0x78, 0xcd, 0x5a, 0xf4 59 , 0x1f, 0xdd, 0xa8, 0x33, 0x88, 0x07, 0xc7, 0x31, 0xb1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xec, 0x5f 60 , 0x60, 0x51, 0x7f, 0xa9, 0x19, 0xb5, 0x4a, 0x0d, 0x2d, 0xe5, 0x7a, 0x9f, 0x93, 0xc9, 0x9c, 0xef 61 , 0xa0, 0xe0, 0x3b, 0x4d, 0xae, 0x2a, 0xf5, 0xb0, 0xc8, 0xeb, 0xbb, 0x3c, 0x83, 0x53, 0x99, 0x61 62 , 0x17, 0x2b, 0x04, 0x7e, 0xba, 0x77, 0xd6, 0x26, 0xe1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0c, 0x7d ], 63 64 /* rotate the word eight bits to the left */ 65 rotate:function(word) 66 { 67 var c = word[0]; 68 for (var i = 0; i < 3; i++) 69 word[i] = word[i+1]; 70 word[3] = c; 71 72 return word; 73 }, 74 75 // Rijndael Rcon 76 Rcon:[ 77 0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 78 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3,
79 0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, 80 0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d, 81 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 82 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 83 0xfa, 0xef, 0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, 0x25, 84 0x4a, 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d, 0x01, 85 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 86 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 87 0xef, 0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, 0x25, 0x4a, 88 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, 89 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a, 90 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 91 0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, 92 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, 0x04, 93 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a, 0x2f, 94 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 95 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, 0x33, 96 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb ], 97 98 G2X: [ 99 0x00, 0x02, 0x04, 0x06, 0x08, 0x0a, 0x0c, 0x0e, 0x10, 0x12, 0x14, 0x16, 100 0x18, 0x1a, 0x1c, 0x1e, 0x20, 0x22, 0x24, 0x26, 0x28, 0x2a, 0x2c, 0x2e, 101 0x30, 0x32, 0x34, 0x36, 0x38, 0x3a, 0x3c, 0x3e, 0x40, 0x42, 0x44, 0x46, 102 0x48, 0x4a, 0x4c, 0x4e, 0x50, 0x52, 0x54, 0x56, 0x58, 0x5a, 0x5c, 0x5e, 103 0x60, 0x62, 0x64, 0x66, 0x68, 0x6a, 0x6c, 0x6e, 0x70, 0x72, 0x74, 0x76, 104 0x78, 0x7a, 0x7c, 0x7e, 0x80, 0x82, 0x84, 0x86, 0x88, 0x8a, 0x8c, 0x8e, 105 0x90, 0x92, 0x94, 0x96, 0x98, 0x9a, 0x9c, 0x9e, 0xa0, 0xa2, 0xa4, 0xa6, 106 0xa8, 0xaa, 0xac, 0xae, 0xb0, 0xb2, 0xb4, 0xb6, 0xb8, 0xba, 0xbc, 0xbe, 107 0xc0, 0xc2, 0xc4, 0xc6, 0xc8, 0xca, 0xcc, 0xce, 0xd0, 0xd2, 0xd4, 0xd6, 108 0xd8, 0xda, 0xdc, 0xde, 0xe0, 0xe2, 0xe4, 0xe6, 0xe8, 0xea, 0xec, 0xee, 109 0xf0, 0xf2, 0xf4, 0xf6, 0xf8, 0xfa, 0xfc, 0xfe, 0x1b, 0x19, 0x1f, 0x1d, 110 0x13, 0x11, 0x17, 0x15, 0x0b, 0x09, 0x0f, 0x0d, 0x03, 0x01, 0x07, 0x05, 111 0x3b, 0x39, 0x3f, 0x3d, 0x33, 0x31, 0x37, 0x35, 0x2b, 0x29, 0x2f, 0x2d, 112 0x23, 0x21, 0x27, 0x25, 0x5b, 0x59, 0x5f, 0x5d, 0x53, 0x51, 0x57, 0x55, 113 0x4b, 0x49, 0x4f, 0x4d, 0x43, 0x41, 0x47, 0x45, 0x7b, 0x79, 0x7f, 0x7d, 114 0x73, 0x71, 0x77, 0x75, 0x6b, 0x69, 0x6f, 0x6d, 0x63, 0x61, 0x67, 0x65, 115 0x9b, 0x99, 0x9f, 0x9d, 0x93, 0x91, 0x97, 0x95, 0x8b, 0x89, 0x8f, 0x8d, 116 0x83, 0x81, 0x87, 0x85, 0xbb, 0xb9, 0xbf, 0xbd, 0xb3, 0xb1, 0xb7, 0xb5, 117 0xab, 0xa9, 0xaf, 0xad, 0xa3, 0xa1, 0xa7, 0xa5, 0xdb, 0xd9, 0xdf, 0xdd, 118 0xd3, 0xd1, 0xd7, 0xd5, 0xcb, 0xc9, 0xcf, 0xcd, 0xc3, 0xc1, 0xc7, 0xc5, 119 0xfb, 0xf9, 0xff, 0xfd, 0xf3, 0xf1, 0xf7, 0xf5, 0xeb, 0xe9, 0xef, 0xed, 120 0xe3, 0xe1, 0xe7, 0xe5 121 ], 122 123 G3X: [ 124 0x00, 0x03, 0x06, 0x05, 0x0c, 0x0f, 0x0a, 0x09, 0x18, 0x1b, 0x1e, 0x1d, 125 0x14, 0x17, 0x12, 0x11, 0x30, 0x33, 0x36, 0x35, 0x3c, 0x3f, 0x3a, 0x39, 126 0x28, 0x2b, 0x2e, 0x2d, 0x24, 0x27, 0x22, 0x21, 0x60, 0x63, 0x66, 0x65, 127 0x6c, 0x6f, 0x6a, 0x69, 0x78, 0x7b, 0x7e, 0x7d, 0x74, 0x77, 0x72, 0x71, 128 0x50, 0x53, 0x56, 0x55, 0x5c, 0x5f, 0x5a, 0x59, 0x48, 0x4b, 0x4e, 0x4d, 129 0x44, 0x47, 0x42, 0x41, 0xc0, 0xc3, 0xc6, 0xc5, 0xcc, 0xcf, 0xca, 0xc9, 130 0xd8, 0xdb, 0xde, 0xdd, 0xd4, 0xd7, 0xd2, 0xd1, 0xf0, 0xf3, 0xf6, 0xf5, 131 0xfc, 0xff, 0xfa, 0xf9, 0xe8, 0xeb, 0xee, 0xed, 0xe4, 0xe7, 0xe2, 0xe1, 132 0xa0, 0xa3, 0xa6, 0xa5, 0xac, 0xaf, 0xaa, 0xa9, 0xb8, 0xbb, 0xbe, 0xbd, 133 0xb4, 0xb7, 0xb2, 0xb1, 0x90, 0x93, 0x96, 0x95, 0x9c, 0x9f, 0x9a, 0x99, 134 0x88, 0x8b, 0x8e, 0x8d, 0x84, 0x87, 0x82, 0x81, 0x9b, 0x98, 0x9d, 0x9e, 135 0x97, 0x94, 0x91, 0x92, 0x83, 0x80, 0x85, 0x86, 0x8f, 0x8c, 0x89, 0x8a, 136 0xab, 0xa8, 0xad, 0xae, 0xa7, 0xa4, 0xa1, 0xa2, 0xb3, 0xb0, 0xb5, 0xb6, 137 0xbf, 0xbc, 0xb9, 0xba, 0xfb, 0xf8, 0xfd, 0xfe, 0xf7, 0xf4, 0xf1, 0xf2, 138 0xe3, 0xe0, 0xe5, 0xe6, 0xef, 0xec, 0xe9, 0xea, 0xcb, 0xc8, 0xcd, 0xce,
139 0xc7, 0xc4, 0xc1, 0xc2, 0xd3, 0xd0, 0xd5, 0xd6, 0xdf, 0xdc, 0xd9, 0xda, 140 0x5b, 0x58, 0x5d, 0x5e, 0x57, 0x54, 0x51, 0x52, 0x43, 0x40, 0x45, 0x46, 141 0x4f, 0x4c, 0x49, 0x4a, 0x6b, 0x68, 0x6d, 0x6e, 0x67, 0x64, 0x61, 0x62, 142 0x73, 0x70, 0x75, 0x76, 0x7f, 0x7c, 0x79, 0x7a, 0x3b, 0x38, 0x3d, 0x3e, 143 0x37, 0x34, 0x31, 0x32, 0x23, 0x20, 0x25, 0x26, 0x2f, 0x2c, 0x29, 0x2a, 144 0x0b, 0x08, 0x0d, 0x0e, 0x07, 0x04, 0x01, 0x02, 0x13, 0x10, 0x15, 0x16, 145 0x1f, 0x1c, 0x19, 0x1a 146 ], 147 148 G9X: [ 149 0x00, 0x09, 0x12, 0x1b, 0x24, 0x2d, 0x36, 0x3f, 0x48, 0x41, 0x5a, 0x53, 150 0x6c, 0x65, 0x7e, 0x77, 0x90, 0x99, 0x82, 0x8b, 0xb4, 0xbd, 0xa6, 0xaf, 151 0xd8, 0xd1, 0xca, 0xc3, 0xfc, 0xf5, 0xee, 0xe7, 0x3b, 0x32, 0x29, 0x20, 152 0x1f, 0x16, 0x0d, 0x04, 0x73, 0x7a, 0x61, 0x68, 0x57, 0x5e, 0x45, 0x4c, 153 0xab, 0xa2, 0xb9, 0xb0, 0x8f, 0x86, 0x9d, 0x94, 0xe3, 0xea, 0xf1, 0xf8, 154 0xc7, 0xce, 0xd5, 0xdc, 0x76, 0x7f, 0x64, 0x6d, 0x52, 0x5b, 0x40, 0x49, 155 0x3e, 0x37, 0x2c, 0x25, 0x1a, 0x13, 0x08, 0x01, 0xe6, 0xef, 0xf4, 0xfd, 156 0xc2, 0xcb, 0xd0, 0xd9, 0xae, 0xa7, 0xbc, 0xb5, 0x8a, 0x83, 0x98, 0x91, 157 0x4d, 0x44, 0x5f, 0x56, 0x69, 0x60, 0x7b, 0x72, 0x05, 0x0c, 0x17, 0x1e, 158 0x21, 0x28, 0x33, 0x3a, 0xdd, 0xd4, 0xcf, 0xc6, 0xf9, 0xf0, 0xeb, 0xe2, 159 0x95, 0x9c, 0x87, 0x8e, 0xb1, 0xb8, 0xa3, 0xaa, 0xec, 0xe5, 0xfe, 0xf7, 160 0xc8, 0xc1, 0xda, 0xd3, 0xa4, 0xad, 0xb6, 0xbf, 0x80, 0x89, 0x92, 0x9b, 161 0x7c, 0x75, 0x6e, 0x67, 0x58, 0x51, 0x4a, 0x43, 0x34, 0x3d, 0x26, 0x2f, 162 0x10, 0x19, 0x02, 0x0b, 0xd7, 0xde, 0xc5, 0xcc, 0xf3, 0xfa, 0xe1, 0xe8, 163 0x9f, 0x96, 0x8d, 0x84, 0xbb, 0xb2, 0xa9, 0xa0, 0x47, 0x4e, 0x55, 0x5c, 164 0x63, 0x6a, 0x71, 0x78, 0x0f, 0x06, 0x1d, 0x14, 0x2b, 0x22, 0x39, 0x30, 165 0x9a, 0x93, 0x88, 0x81, 0xbe, 0xb7, 0xac, 0xa5, 0xd2, 0xdb, 0xc0, 0xc9, 166 0xf6, 0xff, 0xe4, 0xed, 0x0a, 0x03, 0x18, 0x11, 0x2e, 0x27, 0x3c, 0x35, 167 0x42, 0x4b, 0x50, 0x59, 0x66, 0x6f, 0x74, 0x7d, 0xa1, 0xa8, 0xb3, 0xba, 168 0x85, 0x8c, 0x97, 0x9e, 0xe9, 0xe0, 0xfb, 0xf2, 0xcd, 0xc4, 0xdf, 0xd6, 169 0x31, 0x38, 0x23, 0x2a, 0x15, 0x1c, 0x07, 0x0e, 0x79, 0x70, 0x6b, 0x62, 170 0x5d, 0x54, 0x4f, 0x46 171 ], 172 173 GBX: [ 174 0x00, 0x0b, 0x16, 0x1d, 0x2c, 0x27, 0x3a, 0x31, 0x58, 0x53, 0x4e, 0x45, 175 0x74, 0x7f, 0x62, 0x69, 0xb0, 0xbb, 0xa6, 0xad, 0x9c, 0x97, 0x8a, 0x81, 176 0xe8, 0xe3, 0xfe, 0xf5, 0xc4, 0xcf, 0xd2, 0xd9, 0x7b, 0x70, 0x6d, 0x66, 177 0x57, 0x5c, 0x41, 0x4a, 0x23, 0x28, 0x35, 0x3e, 0x0f, 0x04, 0x19, 0x12, 178 0xcb, 0xc0, 0xdd, 0xd6, 0xe7, 0xec, 0xf1, 0xfa, 0x93, 0x98, 0x85, 0x8e, 179 0xbf, 0xb4, 0xa9, 0xa2, 0xf6, 0xfd, 0xe0, 0xeb, 0xda, 0xd1, 0xcc, 0xc7, 180 0xae, 0xa5, 0xb8, 0xb3, 0x82, 0x89, 0x94, 0x9f, 0x46, 0x4d, 0x50, 0x5b, 181 0x6a, 0x61, 0x7c, 0x77, 0x1e, 0x15, 0x08, 0x03, 0x32, 0x39, 0x24, 0x2f, 182 0x8d, 0x86, 0x9b, 0x90, 0xa1, 0xaa, 0xb7, 0xbc, 0xd5, 0xde, 0xc3, 0xc8, 183 0xf9, 0xf2, 0xef, 0xe4, 0x3d, 0x36, 0x2b, 0x20, 0x11, 0x1a, 0x07, 0x0c, 184 0x65, 0x6e, 0x73, 0x78, 0x49, 0x42, 0x5f, 0x54, 0xf7, 0xfc, 0xe1, 0xea, 185 0xdb, 0xd0, 0xcd, 0xc6, 0xaf, 0xa4, 0xb9, 0xb2, 0x83, 0x88, 0x95, 0x9e, 186 0x47, 0x4c, 0x51, 0x5a, 0x6b, 0x60, 0x7d, 0x76, 0x1f, 0x14, 0x09, 0x02, 187 0x33, 0x38, 0x25, 0x2e, 0x8c, 0x87, 0x9a, 0x91, 0xa0, 0xab, 0xb6, 0xbd, 188 0xd4, 0xdf, 0xc2, 0xc9, 0xf8, 0xf3, 0xee, 0xe5, 0x3c, 0x37, 0x2a, 0x21, 189 0x10, 0x1b, 0x06, 0x0d, 0x64, 0x6f, 0x72, 0x79, 0x48, 0x43, 0x5e, 0x55, 190 0x01, 0x0a, 0x17, 0x1c, 0x2d, 0x26, 0x3b, 0x30, 0x59, 0x52, 0x4f, 0x44, 191 0x75, 0x7e, 0x63, 0x68, 0xb1, 0xba, 0xa7, 0xac, 0x9d, 0x96, 0x8b, 0x80, 192 0xe9, 0xe2, 0xff, 0xf4, 0xc5, 0xce, 0xd3, 0xd8, 0x7a, 0x71, 0x6c, 0x67, 193 0x56, 0x5d, 0x40, 0x4b, 0x22, 0x29, 0x34, 0x3f, 0x0e, 0x05, 0x18, 0x13, 194 0xca, 0xc1, 0xdc, 0xd7, 0xe6, 0xed, 0xf0, 0xfb, 0x92, 0x99, 0x84, 0x8f, 195 0xbe, 0xb5, 0xa8, 0xa3 196 ], 197 198 GDX: [ 199 0x00, 0x0d, 0x1a, 0x17, 0x34, 0x39, 0x2e, 0x23, 0x68, 0x65, 0x72, 0x7f, 200 0x5c, 0x51, 0x46, 0x4b, 0xd0, 0xdd, 0xca, 0xc7, 0xe4, 0xe9, 0xfe, 0xf3, 201 0xb8, 0xb5, 0xa2, 0xaf, 0x8c, 0x81, 0x96, 0x9b, 0xbb, 0xb6, 0xa1, 0xac, 202 0x8f, 0x82, 0x95, 0x98, 0xd3, 0xde, 0xc9, 0xc4, 0xe7, 0xea, 0xfd, 0xf0, 203 0x6b, 0x66, 0x71, 0x7c, 0x5f, 0x52, 0x45, 0x48, 0x03, 0x0e, 0x19, 0x14, 204 0x37, 0x3a, 0x2d, 0x20, 0x6d, 0x60, 0x77, 0x7a, 0x59, 0x54, 0x43, 0x4e, 205 0x05, 0x08, 0x1f, 0x12, 0x31, 0x3c, 0x2b, 0x26, 0xbd, 0xb0, 0xa7, 0xaa, 206 0x89, 0x84, 0x93, 0x9e, 0xd5, 0xd8, 0xcf, 0xc2, 0xe1, 0xec, 0xfb, 0xf6, 207 0xd6, 0xdb, 0xcc, 0xc1, 0xe2, 0xef, 0xf8, 0xf5, 0xbe, 0xb3, 0x
207a4, 0xa9, 208 0x8a, 0x87, 0x90, 0x9d, 0x06, 0x0b, 0x1c, 0x11, 0x32, 0x3f, 0x28, 0x25, 209 0x6e, 0x63, 0x74, 0x79, 0x5a, 0x57, 0x40, 0x4d, 0xda, 0xd7, 0xc0, 0xcd, 210 0xee, 0xe3, 0xf4, 0xf9, 0xb2, 0xbf, 0xa8, 0xa5, 0x86, 0x8b, 0x9c, 0x91, 211 0x0a, 0x07, 0x10, 0x1d, 0x3e, 0x33, 0x24, 0x29, 0x62, 0x6f, 0x78, 0x75, 212 0x56, 0x5b, 0x4c, 0x41, 0x61, 0x6c, 0x7b, 0x76, 0x55, 0x58, 0x4f, 0x42, 213 0x09, 0x04, 0x13, 0x1e, 0x3d, 0x30, 0x27, 0x2a, 0xb1, 0xbc, 0xab, 0xa6, 214 0x85, 0x88, 0x9f, 0x92, 0xd9, 0xd4, 0xc3, 0xce, 0xed, 0xe0, 0xf7, 0xfa, 215 0xb7, 0xba, 0xad, 0xa0, 0x83, 0x8e, 0x99, 0x94, 0xdf, 0xd2, 0xc5, 0xc8, 216 0xeb, 0xe6, 0xf1, 0xfc, 0x67, 0x6a, 0x7d, 0x70, 0x53, 0x5e, 0x49, 0x44, 217 0x0f, 0x02, 0x15, 0x18, 0x3b, 0x36, 0x21, 0x2c, 0x0c, 0x01, 0x16, 0x1b, 218 0x38, 0x35, 0x22, 0x2f, 0x64, 0x69, 0x7e, 0x73, 0x50, 0x5d, 0x4a, 0x47, 219 0xdc, 0xd1, 0xc6, 0xcb, 0xe8, 0xe5, 0xf2, 0xff, 0xb4, 0xb9, 0xae, 0xa3, 220 0x80, 0x8d, 0x9a, 0x97 221 ], 222 223 GEX: [ 224 0x00, 0x0e, 0x1c, 0x12, 0x38, 0x36, 0x24, 0x2a, 0x70, 0x7e, 0x6c, 0x62, 225 0x48, 0x46, 0x54, 0x5a, 0xe0, 0xee, 0xfc, 0xf2, 0xd8, 0xd6, 0xc4, 0xca, 226 0x90, 0x9e, 0x8c, 0x82, 0xa8, 0xa6, 0xb4, 0xba, 0xdb, 0xd5, 0xc7, 0xc9, 227 0xe3, 0xed, 0xff, 0xf1, 0xab, 0xa5, 0xb7, 0xb9, 0x93, 0x9d, 0x8f, 0x81, 228 0x3b, 0x35, 0x27, 0x29, 0x03, 0x0d, 0x1f, 0x11, 0x4b, 0x45, 0x57, 0x59, 229 0x73, 0x7d, 0x6f, 0x61, 0xad, 0xa3, 0xb1, 0xbf, 0x95, 0x9b, 0x89, 0x87, 230 0xdd, 0xd3, 0xc1, 0xcf, 0xe5, 0xeb, 0xf9, 0xf7, 0x4d, 0x43, 0x51, 0x5f, 231 0x75, 0x7b, 0x69, 0x67, 0x3d, 0x33, 0x21, 0x2f, 0x05, 0x0b, 0x19, 0x17, 232 0x76, 0x78, 0x6a, 0x64, 0x4e, 0x40, 0x52, 0x5c, 0x06, 0x08, 0x1a, 0x14, 233 0x3e, 0x30, 0x22, 0x2c, 0x96, 0x98, 0x8a, 0x84, 0xae, 0xa0, 0xb2, 0xbc, 234 0xe6, 0xe8, 0xfa, 0xf4, 0xde, 0xd0, 0xc2, 0xcc, 0x41, 0x4f, 0x5d, 0x53, 235 0x79, 0x77, 0x65, 0x6b, 0x31, 0x3f, 0x2d, 0x23, 0x09, 0x07, 0x15, 0x1b, 236 0xa1, 0xaf, 0xbd, 0xb3, 0x99, 0x97, 0x85, 0x8b, 0xd1, 0xdf, 0xcd, 0xc3, 237 0xe9, 0xe7, 0xf5, 0xfb, 0x9a, 0x94, 0x86, 0x88, 0xa2, 0xac, 0xbe, 0xb0, 238 0xea, 0xe4, 0xf6, 0xf8, 0xd2, 0xdc, 0xce, 0xc0, 0x7a, 0x74, 0x66, 0x68, 239 0x42, 0x4c, 0x5e, 0x50, 0x0a, 0x04, 0x16, 0x18, 0x32, 0x3c, 0x2e, 0x20, 240 0xec, 0xe2, 0xf0, 0xfe, 0xd4, 0xda, 0xc8, 0xc6, 0x9c, 0x92, 0x80, 0x8e, 241 0xa4, 0xaa, 0xb8, 0xb6, 0x0c, 0x02, 0x10, 0x1e, 0x34, 0x3a, 0x28, 0x26, 242 0x7c, 0x72, 0x60, 0x6e, 0x44, 0x4a, 0x58, 0x56, 0x37, 0x39, 0x2b, 0x25, 243 0x0f, 0x01, 0x13, 0x1d, 0x47, 0x49, 0x5b, 0x55, 0x7f, 0x71, 0x63, 0x6d, 244 0xd7, 0xd9, 0xcb, 0xc5, 0xef, 0xe1, 0xf3, 0xfd, 0xa7, 0xa9, 0xbb, 0xb5, 245 0x9f, 0x91, 0x83, 0x8d 246 ], 247 248 // Key Schedule Core 249 core:function(word,iteration) 250 { 251 /* rotate the 32-bit word 8 bits to the left */ 252 word = this.rotate(word); 253 /* apply S-Box substitution on all 4 parts of the 32-bit word */ 254 for (var i = 0; i < 4; ++i) 255 word[i] = this.sbox[word[i]]; 256 /* XOR the output of the rcon operation with i to the first part (leftmost) only */ 257 word[0] = word[0]^this.Rcon[iteration]; 258 return word; 259 }, 260 261 /* Rijndael's key expansion 262 * expands an 128,192,256 key into an 176,208,240 bytes key 263 * 264 * expandedKey is a pointer to an char array of large enough size 265 * key is a pointer to a non-expanded key 266 */ 267 expandKey:function(key,size) 268 { 269 var expandedKeySize = (16*(this.numberOfRounds(size)+1)); 270 271 /* current expanded keySize, in bytes */ 272 var currentSize = 0; 273 var rconIteration = 1; 274 var t = []; // temporary 4-byte variable 275 276 var expandedKey = []; 277 for(var i = 0;i < expandedKeySize;i++) 278 expandedKey[i] = 0; 279 280 /* set the 16,24,32 bytes of the expanded key to the input key */ 281 for (var j = 0; j < size; j++) 282 expandedKey[j] = key[j]; 283 currentSize += size; 284 285 while (currentSize < expandedKeySize) 286 { 287 /* assign the previous 4 bytes to the temporary value t */ 288 for (var k = 0; k < 4; k++) 289 t[k] = expandedKey[(currentSize - 4) + k]; 290 291 /* every 16,24,32 bytes we apply the core schedule to t 292 * and increment rconIteration afterwards 293 */ 294 if(currentSize % size == 0) 295 t = this.core(t, rconIteration++); 296 297 /* For 256-bit keys, we add an extra sbox to the calculation */ 298 if(size == this.keySize.SIZE_256 && ((currentSize % size) == 16)) 299 for(var l = 0; l < 4; l++) 300 t[l] = this.sbox[t[l]]; 301 302 /* We XOR t with the four-byte block 16,24,32 bytes before the new expanded key.
303 * This becomes the next four bytes in the expanded key. 304 */ 305 for(var m = 0; m < 4; m++) { 306 expandedKey[currentSize] = expandedKey[currentSize - size] ^ t[m]; 307 currentSize++; 308 } 309 } 310 return expandedKey; 311 }, 312 313 // Adds (XORs) the round key to the state 314 addRoundKey:function(state,roundKey) 315 { 316 for (var i = 0; i < 16; i++) 317 state[i] ^= roundKey[i]; 318 return state; 319 }, 320 321 // Creates a round key from the given expanded key and the 322 // position within the expanded key. 323 createRoundKey:function(expandedKey,roundKeyPointer) 324 { 325 var roundKey = []; 326 for (var i = 0; i < 4; i++) 327 for (var j = 0; j < 4; j++) 328 roundKey[j*4+i] = expandedKey[roundKeyPointer + i*4 + j]; 329 return roundKey; 330 }, 331 332 /* substitute all the values from the state with the value in the SBox 333 * using the state value as index for the SBox 334 */ 335 subBytes:function(state,isInv) 336 { 337 for (var i = 0; i < 16; i++) 338 state[i] = isInv?this.rsbox[state[i]]:this.sbox[state[i]]; 339 return state; 340 }, 341 342 /* iterate over the 4 rows and call shiftRow() with that row */ 343 shiftRows:function(state,isInv) 344 { 345 for (var i = 0; i < 4; i++) 346 state = this.shiftRow(state,i*4, i,isInv); 347 return state; 348 }, 349 350 /* each iteration shifts the row to the left by 1 */ 351 shiftRow:function(state,statePointer,nbr,isInv) 352 { 353 for (var i = 0; i < nbr; i++) 354 { 355 if(isInv) 356 { 357 var tmp = state[statePointer + 3]; 358 for (var j = 3; j > 0; j--) 359 state[statePointer + j] = state[statePointer + j-1]; 360 state[statePointer] = tmp; 361 } 362 else 363 { 364 var tmp = state[statePointer]; 365 for (var j = 0; j < 3; j++) 366 state[statePointer + j] = state[statePointer + j+1]; 367 state[statePointer + 3] = tmp; 368 } 369 } 370 return state; 371 }, 372 373 // galois multiplication of 8 bit characters a and b 374 galois_multiplication:function(a,b) 375 { 376 var p = 0; 377 for(var counter = 0; counter < 8; counter++) 378 { 379 if((b & 1) == 1) 380 p ^= a; 381 if(p > 0x100) p ^= 0x100; 382 var hi_bit_set = (a & 0x80); //keep p 8 bit 383 a <<= 1; 384 if(a > 0x100) a ^= 0x100; //keep a 8 bit 385 if(hi_bit_set == 0x80) 386 a ^= 0x1b; 387 if(a > 0x100) a ^= 0x100; //keep a 8 bit 388 b >>= 1; 389 if(b > 0x100) b ^= 0x100; //keep b 8 bit 390 } 391 return p; 392 }, 393 394 // galois multipication of the 4x4 matrix 395 mixColumns:function(state,isInv) 396 { 397 var column = []; 398 /* iterate over the 4 columns */ 399 for (var i = 0; i < 4; i++) 400 { 401 /* construct one column by iterating over the 4 rows */ 402 for (var j = 0; j < 4; j++) 403 column[j] = state[(j*4)+i]; 404 /* apply the mixColumn on one column */ 405 column = this.mixColumn(column,isInv); 406 /* put the values back into the state */ 407 for (var k = 0; k < 4; k++) 408 state[(k*4)+i] = column[k]; 409 } 410 return state; 411 }, 412 413 // galois multipication of 1 column of the 4x4 matrix 414 mixColumn:function(column,isInv) 415 { 416 var mult = []; 417 if(isInv) 418 mult = [14,9,13,11]; 419 else 420 mult = [2,1,1,3]; 421 var cpy = []; 422 for(var i = 0; i < 4; i++) 423 cpy[i] = column[i]; 424 425 column[0] = this.galois_multiplication(cpy[0],mult[0]) ^ 426 this.galois_multiplication(cpy[3],mult[1]) ^ 427 this.galois_multiplication(cpy[2],mult[2]) ^ 428 this.galois_multiplication(cpy[1],mult[3]); 429 column[1] = this.galois_multiplication(cpy[1],mult[0]) ^ 430 this.galois_multiplication(cpy[0],mult[1]) ^ 431 this.galois_multiplication(cpy[3],mult[2]) ^ 432 this.galois_multiplication(cpy[2],mult[3]); 433 column[2] = this.galois_multiplication(cpy[2],mult[0]) ^ 434 this.galois_multiplication(cpy[1],mult[1]) ^ 435 this.galois_multiplication(cpy[0],mult[2]) ^ 436 this.galois_multiplication(cpy[3],mult[3]); 437 column[3] = this.galois_multiplication(cpy[3],mult[0]) ^ 438 this.galois_multiplication(cpy[2],mult[1]) ^ 439 this.galois_multiplication(cpy[1],mult[2]) ^ 440 this.galois_multiplication(cpy[0],mult[3]); 441 return column; 442 }, 443 444 // applies the 4 operations of the forward round in sequence 445 round:function(state, roundKey) 446 { 447 state = this.subBytes(state,false); 448 state = this.shiftRows(state,false); 449 state = this.mixColumns(state,false); 450 state = this.addRoundKey(state, roundKey); 451 return state; 452 }, 453 454 // applies the 4 operations of the inverse round in sequence 455 invRound:function(state,roundKey) 456 { 457 state = this.shiftRows(state,true); 458 state = this.subBytes(state,true); 459 state = this.addRoundKey(state, roundKey); 460 state = this.mixColumns(state,true); 461 return state; 462 }, 463 464 /* 465 * Perform the initial operations, the standard round, and the final operations 466 * of the forward aes, creating a round key for each round 467 */ 468 main:function(state,expandedKey,nbrRounds) 469 { 470 state = this.addRoundKey(state, this.createRoundKey(expandedKey,0)); 471 for (var i = 1; i < nbrRounds; i++) 472 state = this.round(state, this.createRoundKey(expandedKey,16*i)); 473 state = this.subBytes(state,false); 474 state = this.shiftRows(state,false); 475 state = this.addRoundKey(state, this.createRoundKey(expandedKey,16*nbrRounds)); 476 return state; 477 }, 478 479 /* 480 * Perform the initial operations, the standard round, and the final operations 481 * of the inverse aes, creating a round key for each round 482 */ 483 invMain:function(state, expandedKey, nbrRounds) 484 { 485 state = this.addRoundKey(state, this.createRoundKey(expandedKey,16*nbrRounds)); 486 for (var i = nbrRounds-1; i > 0; i--) 487 state = this.invRound(state, this.createRoundKey(expandedKey,16*i)); 488 state = this.shiftRows(state,true); 489 state = this.subBytes(state,true); 490 state = this.addRoundKey(state, this.createRoundKey(expandedKey,0)); 491 return state; 492 }, 493 494 numberOfRounds:function(size) 495 { 496 var nbrRounds; 497 switch (size) /* set the number of rounds */ 498 { 499 case this.keySize.SIZE_128: 500 nbrRounds = 10; 501 break; 502 case this.keySize.SIZE_192: 503 nbrRounds = 12; 504 break; 505 case this.keySize.SIZE_256: 506 nbrRounds = 14; 507 break; 508 default: 509 return null; 510 break; 511 } 512 return nbrRounds; 513 }, 514 515 // encrypts a 128 bit input block against the given key of size specified 516 encrypt:function(input,key,size) 517 { 518 var output = []; 519 var block = []; /* the 128 bit block to encode */ 520 var nbrRounds = this.numberOfRounds(size); 521 /* Set the block values, for the block: 522 * a0,0 a0,1 a0,2 a0,3 523 * a1,0 a1,1 a1,2 a1,3 524 * a2,0 a2,1 a2,2 a2,3 525 * a3,0 a3,1 a3,2 a3,3 526 * the mapping order is a0,0 a1,0 a2,0 a3,0 a0,1 a1,1 ... a2,3 a3,3 527 */ 528 for (var i = 0; i < 4; i++) /* iterate over the columns */ 529 for (var j = 0; j < 4; j++) /* iterate over the rows */
530 block[(i+(j*4))] = input[(i*4)+j]; 531 532 /* expand the key into an 176, 208, 240 bytes key */ 533 var expandedKey = this.expandKey(key, size); /* the expanded key */ 534 /* encrypt the block using the expandedKey */ 535 block = this.main(block, expandedKey, nbrRounds); 536 for (var k = 0; k < 4; k++) /* unmap the block again into the output */ 537 for (var l = 0; l < 4; l++) /* iterate over the rows */ 538 output[(k*4)+l] = block[(k+(l*4))]; 539 return output; 540 }, 541 542 // decrypts a 128 bit input block against the given key of size specified 543 decrypt:function(input, key, size) 544 { 545 var output = []; 546 var block = []; /* the 128 bit block to decode */ 547 var nbrRounds = this.numberOfRounds(size); 548 /* Set the block values, for the block: 549 * a0,0 a0,1 a0,2 a0,3 550 * a1,0 a1,1 a1,2 a1,3 551 * a2,0 a2,1 a2,2 a2,3 552 * a3,0 a3,1 a3,2 a3,3 553 * the mapping order is a0,0 a1,0 a2,0 a3,0 a0,1 a1,1 ... a2,3 a3,3 554 */ 555 for (var i = 0; i < 4; i++) /* iterate over the columns */ 556 for (var j = 0; j < 4; j++) /* iterate over the rows */ 557 block[(i+(j*4))] = input[(i*4)+j]; 558 /* expand the key into an 176, 208, 240 bytes key */ 559 var expandedKey = this.expandKey(key, size); 560 /* decrypt the block using the expandedKey */ 561 block = this.invMain(block, expandedKey, nbrRounds); 562 for (var k = 0; k < 4; k++)/* unmap the block again into the output */ 563 for (var l = 0; l < 4; l++)/* iterate over the rows */ 564 output[(k*4)+l] = block[(k+(l*4))]; 565 return output; 566 } 567 }, 568 /* 569 * END AES SECTION 570 */ 571 572 /* 573 * START MODE OF OPERATION SECTION 574 */ 575 //structure of supported modes of operation 576 modeOfOperation:{ 577 OFB:0, 578 CFB:1, 579 CBC:2 580 }, 581 582 // get a 16 byte block (aes operates on 128bits) 583 getBlock: function(bytesIn,start,end,mode) 584 { 585 if(end - start > 16) 586 end = start + 16; 587 588 return bytesIn.slice(start, end); 589 }, 590 591 /* 592 * Mode of Operation Encryption 593 * bytesIn - Input String as array of bytes 594 * mode - mode of type modeOfOperation 595 * key - a number array of length 'size' 596 * size - the bit length of the key 597 * iv - the 128 bit number array Initialization Vector 598 */ 599 encrypt: function (bytesIn, mode, key, iv) 600 { 601 var size = key.length; 602 if(iv.length%16) 603 { 604 throw 'iv length must be 128 bits.'; 605 } 606 // the AES input/output 607 var byteArray = []; 608 var input = []; 609 var output = []; 610 var ciphertext = []; 611 var cipherOut = []; 612 // char firstRound 613 var firstRound = true; 614 if (mode == this.modeOfOperation.CBC) 615 this.padBytesIn(bytesIn); 616 if (bytesIn !== null) 617 { 618 for (var j = 0;j < Math.ceil(bytesIn.length/16); j++) 619 { 620 var start = j*16; 621 var end = j*16+16; 622 if(j*16+16 > bytesIn.length) 623 end = bytesIn.length; 624 byteArray = this.getBlock(bytesIn,start,end,mode); 625 if (mode == this.modeOfOperation.CFB) 626 { 627 if (firstRound) 628 { 629 output = this.aes.encrypt(iv, key, size); 630 firstRound = false; 631 } 632 else 633 output = this.aes.encrypt(input, key, size); 634 for (var i = 0; i < 16; i++) 635 ciphertext[i] = byteArray[i] ^ output[i]; 636 for(var k = 0;k < end-start;k++) 637 cipherOut.push(ciphertext[k]); 638 input = ciphertext; 639 } 640 else if (mode == this.modeOfOperation.OFB) 641 { 642 if (firstRound) 643 { 644 output = this.aes.encrypt(iv, key, size); 645 firstRound = false; 646 } 647 else 648 output = this.aes.encrypt(input, key, size); 649 for (var i = 0; i < 16; i++) 650 ciphertext[i] = byteArray[i] ^ output[i]; 651 for(var k = 0;k < end-start;k++) 652 cipherOut.push(ciphertext[k]); 653 input = output; 654 } 655 else if (mode == this.modeOfOperation.CBC) 656 { 657 for (var i = 0; i < 16; i++) 658 input[i] = byteArray[i] ^ ((firstRound) ? iv[i] : ciphertext[i]); 659 firstRound = false; 660 ciphertext = this.aes.encrypt(input, key, size); 661 // always 16 bytes because of the padding for CBC 662 for(var k = 0;k < 16;k++) 663 cipherOut.push(ciphertext[k]); 664 } 665 } 666 } 667 return cipherOut; 668 }, 669 670 /* 671 * Mode of Operation Decryption 672 * cipherIn - Encrypted String as array of bytes 673 * originalsize - The unencrypted string length - required for CBC 674 * mode - mode of type modeOfOperation 675 * key - a number array of length 'size' 676 * size - the bit length of the key 677 * iv - the 128 bit number array Initialization Vector 678 */ 679 decrypt:function(cipherIn,mode,key,iv) 680 {
681 var size = key.length; 682 if(iv.length%16) 683 { 684 throw 'iv length must be 128 bits.'; 685 } 686 // the AES input/output 687 var ciphertext = []; 688 var input = []; 689 var output = []; 690 var byteArray = []; 691 var bytesOut = []; 692 // char firstRound 693 var firstRound = true; 694 if (cipherIn !== null) 695 { 696 for (var j = 0;j < Math.ceil(cipherIn.length/16); j++) 697 { 698 var start = j*16; 699 var end = j*16+16; 700 if(j*16+16 > cipherIn.length) 701 end = cipherIn.length; 702 ciphertext = this.getBlock(cipherIn,start,end,mode); 703 if (mode == this.modeOfOperation.CFB) 704 { 705 if (firstRound) 706 { 707 output = this.aes.encrypt(iv, key, size); 708 firstRound = false; 709 } 710 else 711 output = this.aes.encrypt(input, key, size); 712 for (i = 0; i < 16; i++) 713 byteArray[i] = output[i] ^ ciphertext[i]; 714 for(var k = 0;k < end-start;k++) 715 bytesOut.push(byteArray[k]); 716 input = ciphertext; 717 } 718 else if (mode == this.modeOfOperation.OFB) 719 { 720 if (firstRound) 721 { 722 output = this.aes.encrypt(iv, key, size); 723 firstRound = false; 724 } 725 else 726 output = this.aes.encrypt(input, key, size); 727 for (i = 0; i < 16; i++) 728 byteArray[i] = output[i] ^ ciphertext[i]; 729 for(var k = 0;k < end-start;k++) 730 bytesOut.push(byteArray[k]); 731 input = output; 732 } 733 else if(mode == this.modeOfOperation.CBC) 734 { 735 output = this.aes.decrypt(ciphertext, key, size); 736 for (i = 0; i < 16; i++) 737 byteArray[i] = ((firstRound) ? iv[i] : input[i]) ^ output[i]; 738 firstRound = false; 739 for(var k = 0;k < end-start;k++) 740 bytesOut.push(byteArray[k]); 741 input = ciphertext; 742 } 743 } 744 if(mode == this.modeOfOperation.CBC) 745 this.unpadBytesOut(bytesOut); 746 } 747 return bytesOut; 748 }, 749 padBytesIn: function(data) { 750 var len = data.length; 751 var padByte = 16 - (len % 16); 752 for (var i = 0; i < padByte; i++) { 753 data.push(padByte); 754 } 755 }, 756 unpadBytesOut: function(data) { 757 var padCount = 0; 758 var padByte = -1; 759 var blockSize = 16; 760 if (data.length > 16) { 761 for (var i = data.length - 1; i >= data.length-1 - blockSize; i--) { 762 if (data[i] <= blockSize) { 763 if (padByte == -1) 764 padByte = data[i]; 765 if (data[i] != padByte) { 766 padCount = 0; 767 break; 768 } 769 padCount++; 770 } else 771 break; 772 if (padCount == padByte) 773 break; 774 } 775 if (padCount > 0) 776 data.splice(data.length - padCount, padCount); 777 } 778 } 779 /* 780 * END MODE OF OPERATION SECTION 781 */ 782};
Line numbers count LF bytes from the start of the resource, as the search results do. Vendor segments are library code the classifier recognised; they are stored but not indexed. Bytes are shown as Latin1 characters, one per byte.