vnfmarket/src/main/webapp/vnfmarket/node_modules/socket.io-client/lib/vendor/web-socket-js/flash-src/com/hurlant/crypto/Crypto.as

   1 /**\r
   2  * Crypto\r
   3  * \r
   4  * An abstraction layer to instanciate our crypto algorithms\r
   5  * Copyright (c) 2007 Henri Torgemane\r
   6  * \r
   7  * See LICENSE.txt for full license information.\r
   8  */\r
   9 package com.hurlant.crypto\r
  10 {\r
  11         import com.hurlant.crypto.hash.HMAC;\r
  12         import com.hurlant.crypto.hash.MAC;\r
  13         import com.hurlant.crypto.hash.IHash;\r
  14         import com.hurlant.crypto.hash.MD2;\r
  15         import com.hurlant.crypto.hash.MD5;\r
  16         import com.hurlant.crypto.hash.SHA1;\r
  17         import com.hurlant.crypto.hash.SHA224;\r
  18         import com.hurlant.crypto.hash.SHA256;\r
  19         import com.hurlant.crypto.prng.ARC4;\r
  20         import com.hurlant.crypto.rsa.RSAKey;\r
  21         import com.hurlant.crypto.symmetric.AESKey;\r
  22         import com.hurlant.crypto.symmetric.BlowFishKey;\r
  23         import com.hurlant.crypto.symmetric.CBCMode;\r
  24         import com.hurlant.crypto.symmetric.CFB8Mode;\r
  25         import com.hurlant.crypto.symmetric.CFBMode;\r
  26         import com.hurlant.crypto.symmetric.CTRMode;\r
  27         import com.hurlant.crypto.symmetric.DESKey;\r
  28         import com.hurlant.crypto.symmetric.ECBMode;\r
  29         import com.hurlant.crypto.symmetric.ICipher;\r
  30         import com.hurlant.crypto.symmetric.IMode;\r
  31         import com.hurlant.crypto.symmetric.IPad;\r
  32         import com.hurlant.crypto.symmetric.ISymmetricKey;\r
  33         import com.hurlant.crypto.symmetric.IVMode;\r
  34         import com.hurlant.crypto.symmetric.NullPad;\r
  35         import com.hurlant.crypto.symmetric.OFBMode;\r
  36         import com.hurlant.crypto.symmetric.PKCS5;\r
  37         import com.hurlant.crypto.symmetric.SimpleIVMode;\r
  38         import com.hurlant.crypto.symmetric.TripleDESKey;\r
  39         import com.hurlant.crypto.symmetric.XTeaKey;\r
  40         import com.hurlant.util.Base64;\r
  41         \r
  42         import flash.utils.ByteArray;\r
  43         \r
  44         /**\r
  45          * A class to make it easy to use the rest of the framework.\r
  46          * As a side-effect, using this class will cause most of the framework\r
  47          * to be linked into your application, which is not always what you want.\r
  48          * \r
  49          * If you want to optimize your download size, don't use this class.\r
  50          * (But feel free to read it to get ideas on how to get the algorithm you want.)\r
  51          */\r
  52         public class Crypto\r
  53         {\r
  54                 private var b64:Base64; // we don't use it, but we want the swc to include it, so cheap trick.\r
  55                 \r
  56                 public function Crypto(){\r
  57                 }\r
  58                 \r
  59                 /**\r
  60                  * Things that should work, among others:\r
  61                  *  "aes"\r
  62                  *  "aes-128-ecb"\r
  63                  *  "aes-128-cbc"\r
  64                  *  "aes-128-cfb"\r
  65                  *  "aes-128-cfb8"\r
  66                  *  "aes-128-ofb"\r
  67                  *  "aes-192-cfb"\r
  68                  *  "aes-256-ofb"\r
  69                  *  "blowfish-cbc"\r
  70                  *  "des-ecb"\r
  71                  *  "xtea"\r
  72                  *  "xtea-ecb"\r
  73                  *  "xtea-cbc"\r
  74                  *  "xtea-cfb"\r
  75                  *  "xtea-cfb8"\r
  76                  *  "xtea-ofb"\r
  77                  *  "rc4"\r
  78                  *  "simple-aes-cbc"\r
  79                  */\r
  80                 public static function getCipher(name:String, key:ByteArray, pad:IPad=null):ICipher {\r
  81                         // split name into an array.\r
  82                         var keys:Array = name.split("-");\r
  83                         switch (keys[0]) {\r
  84                                 /**\r
  85                                  * "simple" is a special case. It means:\r
  86                                  * "If using an IV mode, prepend the IV to the ciphertext"\r
  87                                  */\r
  88                                 case "simple":\r
  89                                         keys.shift();\r
  90                                         name = keys.join("-");\r
  91                                         var cipher:ICipher = getCipher(name, key, pad);\r
  92                                         if (cipher is IVMode) {\r
  93                                                 return new SimpleIVMode(cipher as IVMode);\r
  94                                         } else {\r
  95                                                 return cipher;\r
  96                                         }\r
  97                                 /**\r
  98                                  * we support both "aes-128" and "aes128"\r
  99                                  * Technically, you could use "aes192-128", but you'd\r
 100                                  * only be hurting yourself.\r
 101                                  */\r
 102                                 case "aes":\r
 103                                 case "aes128":\r
 104                                 case "aes192":\r
 105                                 case "aes256":\r
 106                                         keys.shift();\r
 107                                         if (key.length*8==keys[0]) {\r
 108                                                 // support for "aes-128-..." and such.\r
 109                                                 keys.shift();\r
 110                                         }\r
 111                                         return getMode(keys[0], new AESKey(key), pad);\r
 112                                 break;\r
 113                                 case "bf":\r
 114                                 case "blowfish":\r
 115                                         keys.shift();\r
 116                                         return getMode(keys[0], new BlowFishKey(key), pad);\r
 117                                 /**\r
 118                                  * des-ede and des-ede3 are both equivalent to des3.\r
 119                                  * the choice between 2tdes and 3tdes is made based\r
 120                                  * on the length of the key provided.\r
 121                                  */\r
 122                                 case "des":\r
 123                                         keys.shift();\r
 124                                         if (keys[0]!="ede" && keys[0]!="ede3") {\r
 125                                                 return getMode(keys[0], new DESKey(key), pad);\r
 126                                         }\r
 127                                         if (keys.length==1) {\r
 128                                                 keys.push("ecb"); // default mode for 2tdes and 3tdes with openssl enc\r
 129                                         }\r
 130                                         // fall-through to triple des\r
 131                                 case "3des":\r
 132                                 case "des3":\r
 133                                         keys.shift();\r
 134                                         return getMode(keys[0], new TripleDESKey(key), pad);\r
 135                                 case "xtea":\r
 136                                         keys.shift();\r
 137                                         return getMode(keys[0], new XTeaKey(key), pad);\r
 138                                 break;\r
 139                                 /**\r
 140                                  * Technically, you could say "rc4-128" or whatever,\r
 141                                  * but really, the length of the key is what counts here.\r
 142                                  */\r
 143                                 case "rc4":\r
 144                                         keys.shift();\r
 145                                         return new ARC4(key);\r
 146                                 break;\r
 147                         }\r
 148                         return null;\r
 149                 }\r
 150                 \r
 151                 /**\r
 152                  * Returns the size of a key for a given cipher identifier.\r
 153                  */\r
 154                 public static function getKeySize(name:String):uint {\r
 155                         var keys:Array = name.split("-");\r
 156                         switch (keys[0]) {\r
 157                                 case "simple":\r
 158                                         keys.shift();\r
 159                                         return getKeySize(keys.join("-"));\r
 160                                 case "aes128":\r
 161                                         return 16;\r
 162                                 case "aes192":\r
 163                                         return 24;\r
 164                                 case "aes256":\r
 165                                         return 32;\r
 166                                 case "aes":\r
 167                                         keys.shift();\r
 168                                         return parseInt(keys[0])/8;\r
 169                                 case "bf":\r
 170                                 case "blowfish":\r
 171                                         return 16;\r
 172                                 case "des":\r
 173                                         keys.shift();\r
 174                                         switch (keys[0]) {\r
 175                                                 case "ede":\r
 176                                                         return 16;\r
 177                                                 case "ede3":\r
 178                                                         return 24;\r
 179                                                 default:\r
 180                                                         return 8;\r
 181                                         }\r
 182                                 case "3des":\r
 183                                 case "des3":\r
 184                                         return 24;\r
 185                                 case "xtea":\r
 186                                         return 8;\r
 187                                 case "rc4":\r
 188                                         if (parseInt(keys[1])>0) {\r
 189                                                 return parseInt(keys[1])/8;\r
 190                                         }\r
 191                                         return 16; // why not.\r
 192                         }\r
 193                         return 0; // unknown;\r
 194                 }\r
 195                 \r
 196                 private static function getMode(name:String, alg:ISymmetricKey, padding:IPad=null):IMode {\r
 197                         switch (name) {\r
 198                                 case "ecb":\r
 199                                         return new ECBMode(alg, padding);\r
 200                                 case "cfb":\r
 201                                         return new CFBMode(alg, padding);\r
 202                                 case "cfb8":\r
 203                                         return new CFB8Mode(alg, padding);\r
 204                                 case "ofb":\r
 205                                         return new OFBMode(alg, padding);\r
 206                                 case "ctr":\r
 207                                         return new CTRMode(alg, padding);\r
 208                                 case "cbc":\r
 209                                 default:\r
 210                                         return new CBCMode(alg, padding);\r
 211                         }\r
 212                 }\r
 213                 \r
 214                 /**\r
 215                  * Things that should work:\r
 216                  * "md5"\r
 217                  * "sha"\r
 218                  * "sha1"\r
 219                  * "sha224"\r
 220                  * "sha256"\r
 221                  */\r
 222                 public static function getHash(name:String):IHash {\r
 223                         switch(name) {\r
 224                                 case "md2":\r
 225                                         return new MD2;\r
 226                                 case "md5":\r
 227                                         return new MD5;\r
 228                                 case "sha": // let's hope you didn't mean sha-0\r
 229                                 case "sha1":\r
 230                                         return new SHA1;\r
 231                                 case "sha224":\r
 232                                         return new SHA224;\r
 233                                 case "sha256":\r
 234                                         return new SHA256;\r
 235                         }\r
 236                         return null;\r
 237                 }\r
 238                 \r
 239                 /**\r
 240                  * Things that should work:\r
 241                  * "sha1"\r
 242                  * "md5-64"\r
 243                  * "hmac-md5-96"\r
 244                  * "hmac-sha1-128"\r
 245                  * "hmac-sha256-192"\r
 246                  * etc.\r
 247                  */\r
 248                 public static function getHMAC(name:String):HMAC {\r
 249                         var keys:Array = name.split("-");\r
 250                         if (keys[0]=="hmac") keys.shift();\r
 251                         var bits:uint = 0;\r
 252                         if (keys.length>1) {\r
 253                                 bits = parseInt(keys[1]);\r
 254                         }\r
 255                         return new HMAC(getHash(keys[0]), bits);\r
 256                 }\r
 257                 \r
 258 \r
 259                 public static function getMAC(name:String):MAC {\r
 260                         \r
 261                         var keys:Array = name.split("-");\r
 262                         if (keys[0]=="mac") keys.shift();\r
 263                         var bits:uint = 0;\r
 264                         if (keys.length > 1) {\r
 265                                 bits = parseInt(keys[1]);\r
 266                         }\r
 267                         return new MAC(getHash(keys[0]), bits);\r
 268                 }\r
 269                                 \r
 270                 \r
 271                 public static function getPad(name:String):IPad {\r
 272                         switch(name) {\r
 273                                 case "null":\r
 274                                         return new NullPad;\r
 275                                 case "pkcs5":\r
 276                                 default:\r
 277                                         return new PKCS5;\r
 278                         }\r
 279                 }\r
 280                 \r
 281                 /** mostly useless.\r
 282                  */\r
 283                 public static function getRSA(E:String, M:String):RSAKey {\r
 284                         return RSAKey.parsePublicKey(M,E);\r
 285                 }\r
 286         }\r
 287 }