1 29 30 package com.caucho.quercus.lib.mcrypt; 31 32 import com.caucho.quercus.annotation.Optional; 33 import com.caucho.quercus.env.ArrayValue; 34 import com.caucho.quercus.env.ArrayValueImpl; 35 import com.caucho.quercus.env.BooleanValue; 36 import com.caucho.quercus.env.Env; 37 import com.caucho.quercus.env.LongValue; 38 import com.caucho.quercus.env.Value; 39 import com.caucho.quercus.module.AbstractQuercusModule; 40 import com.caucho.util.L10N; 41 import com.caucho.util.RandomUtil; 42 import com.caucho.vfs.Path; 43 44 import java.util.logging.Logger ; 45 46 49 public class McryptModule extends AbstractQuercusModule { 50 private static final L10N L = new L10N(McryptModule.class); 51 52 private static final Logger log = 53 Logger.getLogger(McryptModule.class.getName()); 54 55 public static final int MCRYPT_DEV_RANDOM = 0; 56 public static final int MCRYPT_DEV_URANDOM = 1; 57 public static final int MCRYPT_RAND = 2; 58 59 public static final int MCRYPT_ENCRYPT = 0; 60 public static final int MCRYPT_DECRYPT = 1; 61 62 public static final String MCRYPT_MODE_ECB = "ecb"; 63 public static final String MCRYPT_MODE_CBC = "cbc"; 64 public static final String MCRYPT_MODE_CFB = "cfb"; 65 public static final String MCRYPT_MODE_OFB = "ofb"; 66 public static final String MCRYPT_MODE_NOFB = "nofb"; 67 public static final String MCRYPT_MODE_STREAM = "stream"; 68 69 public static final String MCRYPT_ARCFOUR = "arcfour"; 70 public static final String MCRYPT_BLOWFISH = "blowfish"; 71 public static final String MCRYPT_DES = "des"; 72 public static final String MCRYPT_3DES = "tripledes"; 73 public static final String MCRYPT_RC4 = "RC4"; 74 public static final String MCRYPT_RIJNDAEL_128 = "rijndael-128"; 75 public static final String MCRYPT_RIJNDAEL_192 = "rijndael-192"; 76 public static final String MCRYPT_RIJNDAEL_256 = "rijndael-256"; 77 78 public String []getLoadedExtensions() 79 { 80 return new String [] { "mcrypt" }; 81 } 82 83 86 public static String mcrypt_cbc(Env env, 87 String cipher, 88 String key, 89 String data, 90 int mode, 91 @Optional String iv) 92 { 93 try { 94 Mcrypt mcrypt = new Mcrypt(env, cipher, "cbc"); 95 96 mcrypt.init(key, iv); 97 98 if (mode == MCRYPT_ENCRYPT) 99 return new String (mcrypt.encrypt(data.getBytes())); 100 else 101 return new String (mcrypt.decrypt(data.getBytes())); 102 } catch (Exception e) { 103 throw new RuntimeException (e); 104 } 105 } 106 107 110 public static String mcrypt_cfb(Env env, 111 String cipher, 112 String key, 113 String data, 114 int mode, 115 @Optional String iv) 116 { 117 try { 118 Mcrypt mcrypt = new Mcrypt(env, cipher, "cfb"); 119 120 mcrypt.init(key, iv); 121 122 if (mode == MCRYPT_ENCRYPT) 123 return new String (mcrypt.encrypt(data.getBytes())); 124 else 125 return new String (mcrypt.decrypt(data.getBytes())); 126 } catch (Exception e) { 127 throw new RuntimeException (e); 128 } 129 } 130 131 134 public static String mcrypt_create_iv(int size, 135 @Optional int randomMode) 136 { 137 StringBuilder sb = new StringBuilder (); 138 139 for (int i = 0; i < size; i++) 140 sb.append((char) RandomUtil.nextInt(256)); 141 142 return sb.toString(); 143 } 144 145 148 public static String mcrypt_decrypt(Env env, 149 String cipher, 150 String key, 151 String data, 152 String mode, 153 @Optional String iv) 154 { 155 try { 156 Mcrypt mcrypt = new Mcrypt(env, cipher, mode); 157 158 mcrypt.init(key, iv); 159 160 return new String (mcrypt.decrypt(data.getBytes())); 161 } catch (Exception e) { 162 throw new RuntimeException (e); 163 } 164 } 165 166 169 public static String mcrypt_ecb(Env env, 170 String cipher, 171 String key, 172 String data, 173 int mode, 174 @Optional String iv) 175 { 176 try { 177 Mcrypt mcrypt = new Mcrypt(env, cipher, "ecb"); 178 179 mcrypt.init(key, iv); 180 181 if (mode == MCRYPT_ENCRYPT) 182 return new String (mcrypt.encrypt(data.getBytes())); 183 else 184 return new String (mcrypt.decrypt(data.getBytes())); 185 } catch (Exception e) { 186 throw new RuntimeException (e); 187 } 188 } 189 190 193 public static String mcrypt_enc_get_algorithms_name(Mcrypt mcrypt) 194 { 195 if (mcrypt != null) 196 return mcrypt.get_algorithms_name(); 197 else 198 return ""; 199 } 200 201 204 public static int mcrypt_enc_get_block_size(Mcrypt mcrypt) 205 { 206 if (mcrypt != null) 207 return mcrypt.get_iv_size(); 208 else 209 return 0; 210 } 211 212 215 public static int mcrypt_enc_get_iv_size(Mcrypt mcrypt) 216 { 217 if (mcrypt != null) 218 return mcrypt.get_iv_size(); 219 else 220 return 0; 221 } 222 223 226 public static int mcrypt_enc_get_key_size(Mcrypt mcrypt) 227 { 228 if (mcrypt != null) 229 return mcrypt.get_key_size(); 230 else 231 return 0; 232 } 233 234 237 public static String mcrypt_enc_get_modes_name(Mcrypt mcrypt) 238 { 239 if (mcrypt != null) 240 return mcrypt.get_modes_name(); 241 else 242 return null; 243 } 244 245 248 public static Value mcrypt_enc_get_supported_key_sizes(Mcrypt mcrypt) 249 { 250 if (mcrypt != null) 251 return mcrypt.get_supported_key_sizes(); 252 else 253 return BooleanValue.FALSE; 254 } 255 256 259 public static boolean mcrypt_enc_is_block_algorithm(Mcrypt mcrypt) 260 { 261 if (mcrypt != null) 262 return mcrypt.is_block_algorithm(); 263 else 264 return false; 265 } 266 267 270 public static boolean mcrypt_enc_is_block_algorithm_mode(Mcrypt mcrypt) 271 { 272 if (mcrypt != null) 273 return mcrypt.is_block_algorithm_mode(); 274 else 275 return false; 276 } 277 278 281 public static boolean mcrypt_enc_is_block_mode(Mcrypt mcrypt) 282 { 283 if (mcrypt != null) 284 return mcrypt.is_block_mode(); 285 else 286 return false; 287 } 288 289 292 public static boolean mcrypt_enc_self_test(Mcrypt mcrypt) 293 { 294 if (mcrypt != null) 295 return true; 296 else 297 return false; 298 } 299 300 303 public static String mcrypt_encrypt(Env env, 304 String cipher, 305 String key, 306 String data, 307 String mode, 308 @Optional String iv) 309 { 310 try { 311 Mcrypt mcrypt = new Mcrypt(env, cipher, mode); 312 313 mcrypt.init(key, iv); 314 315 return new String (mcrypt.encrypt(data.getBytes())); 316 } catch (Exception e) { 317 throw new RuntimeException (e); 318 } 319 } 320 321 324 public static String mcrypt_generic(Mcrypt mcrypt, String data) 325 { 326 if (mcrypt == null) 327 return null; 328 else 329 return new String (mcrypt.encrypt(data.getBytes())); 330 } 331 332 335 public static boolean mcrypt_generic_deinit(Mcrypt mcrypt) 336 { 337 if (mcrypt == null) 338 return false; 339 else 340 return mcrypt.deinit(); 341 } 342 343 346 public static Value mcrypt_generic_init(Mcrypt mcrypt, String key, String iv) 347 { 348 if (mcrypt == null) 349 return BooleanValue.FALSE; 350 else 351 return new LongValue(mcrypt.init(key, iv)); 352 } 353 354 357 public static boolean mcrypt_generic_end(Mcrypt mcrypt) 358 { 359 if (mcrypt == null) 360 return false; 361 else { 362 mcrypt.close(); 363 364 return true; 365 } 366 } 367 368 private static final String []ALGORITHMS = { 369 MCRYPT_ARCFOUR, MCRYPT_BLOWFISH, MCRYPT_DES, MCRYPT_3DES, 370 MCRYPT_RC4, MCRYPT_RIJNDAEL_128, MCRYPT_RIJNDAEL_192, 371 MCRYPT_RIJNDAEL_256 372 }; 373 374 377 public static Value mcrypt_list_algorithms(Env env) 378 { 379 ArrayValue array = new ArrayValueImpl(); 380 381 for (int i = 0; i < ALGORITHMS.length; i++) { 382 try { 383 Mcrypt mcrypt = new Mcrypt(env, ALGORITHMS[i], "cbc"); 384 385 array.put(mcrypt.get_algorithms_name()); 386 } catch (Throwable e) { 387 } 388 } 389 390 return array; 391 } 392 393 396 public static Value mcrypt_list_modes(Env env) 397 { 398 ArrayValue array = new ArrayValueImpl(); 399 400 array.put(MCRYPT_MODE_ECB); 401 array.put(MCRYPT_MODE_CBC); 402 array.put(MCRYPT_MODE_CFB); 403 array.put(MCRYPT_MODE_OFB); 404 array.put(MCRYPT_MODE_NOFB); 405 406 return array; 407 } 408 409 410 413 public static boolean mcrypt_module_close(Mcrypt mcrypt) 414 { 415 if (mcrypt == null) 416 return false; 417 else { 418 mcrypt.close(); 419 420 return true; 421 } 422 } 423 424 427 public static int mcrypt_module_get_algo_block_size(Env env, 428 String cipher, 429 @Optional String libDir) 430 { 431 try { 432 Mcrypt mcrypt = new Mcrypt(env, cipher, "cbc"); 433 434 return mcrypt.get_block_size(); 435 } catch (Exception e) { 436 env.error(e); 437 438 return -1; 439 } 440 } 441 442 445 public static int mcrypt_module_get_algo_key_size(Env env, 446 String cipher, 447 @Optional String libDir) 448 { 449 try { 450 Mcrypt mcrypt = new Mcrypt(env, cipher, "cbc"); 451 452 return mcrypt.get_key_size(); 453 } catch (Exception e) { 454 env.error(e); 455 456 return -1; 457 } 458 } 459 460 463 public static Value mcrypt_module_get_supported_key_sizes(Env env, 464 String cipher, 465 @Optional String libDir) 466 { 467 try { 468 Mcrypt mcrypt = new Mcrypt(env, cipher, "cbc"); 469 470 return mcrypt.get_supported_key_sizes(); 471 } catch (Exception e) { 472 env.error(e); 473 474 return BooleanValue.FALSE; 475 } 476 } 477 478 481 public static boolean mcrypt_module_is_block_algorithm(Env env, 482 String cipher, 483 @Optional String libDir) 484 { 485 try { 486 Mcrypt mcrypt = new Mcrypt(env, cipher, "cbc"); 487 488 return mcrypt.is_block_algorithm(); 489 } catch (Exception e) { 490 env.error(e); 491 492 return false; 493 } 494 } 495 496 499 public static boolean mcrypt_module_is_block_algorithm_mode(Env env, 500 String mode, 501 @Optional String libDir) 502 { 503 try { 504 Mcrypt mcrypt = new Mcrypt(env, "des", mode); 505 506 return mcrypt.is_block_algorithm_mode(); 507 } catch (Exception e) { 508 env.error(e); 509 510 return false; 511 } 512 } 513 514 517 public static boolean mcrypt_module_is_block_mode(Env env, 518 String mode, 519 @Optional String libDir) 520 { 521 try { 522 Mcrypt mcrypt = new Mcrypt(env, "des", mode); 523 524 return mcrypt.is_block_mode(); 525 } catch (Exception e) { 526 env.error(e); 527 528 return false; 529 } 530 } 531 532 535 public static boolean mcrypt_module_self_test(Env env, 536 String algorithm, 537 Path libDir) 538 { 539 try { 540 Mcrypt mcrypt = new Mcrypt(env, algorithm, "cbc"); 541 542 return true; 543 } catch (Exception e) { 544 env.error(e); 545 546 return false; 547 } 548 } 549 550 553 public static Value mcrypt_module_open(Env env, 554 String algorithm, 555 Path algorithm_directory, 556 String mode, 557 Path mode_directory) 558 { 559 try { 560 return env.wrapJava(new Mcrypt(env, algorithm, mode)); 561 } catch (Exception e) { 562 env.error(e); 563 564 return BooleanValue.FALSE; 565 } 566 } 567 568 571 public static String mcrypt_ofb(Env env, 572 String cipher, 573 String key, 574 String data, 575 int mode, 576 @Optional String iv) 577 { 578 try { 579 Mcrypt mcrypt = new Mcrypt(env, cipher, "ofb"); 580 581 mcrypt.init(key, iv); 582 583 if (mode == MCRYPT_ENCRYPT) 584 return new String (mcrypt.encrypt(data.getBytes())); 585 else 586 return new String (mcrypt.decrypt(data.getBytes())); 587 } catch (Exception e) { 588 throw new RuntimeException (e); 589 } 590 } 591 592 595 public static String mdecrypt_generic(Mcrypt mcrypt, String data) 596 { 597 if (mcrypt == null) 598 return null; 599 else 600 return new String (mcrypt.decrypt(data.getBytes())); 601 } 602 } 603 | Popular Tags |