corrade-nucleus-nucleons – Blame information for rev 4

Subversion Repositories:
Rev:
Rev Author Line No. Line
2 office 1 /*
2 CryptoJS v3.1.2
3 code.google.com/p/crypto-js
4 (c) 2009-2013 by Jeff Mott. All rights reserved.
5 code.google.com/p/crypto-js/wiki/License
6 */
7 /**
8 * Cipher core components.
9 */
10 CryptoJS.lib.Cipher || (function (undefined) {
11 // Shortcuts
12 var C = CryptoJS;
13 var C_lib = C.lib;
14 var Base = C_lib.Base;
15 var WordArray = C_lib.WordArray;
16 var BufferedBlockAlgorithm = C_lib.BufferedBlockAlgorithm;
17 var C_enc = C.enc;
18 var Utf8 = C_enc.Utf8;
19 var Base64 = C_enc.Base64;
20 var C_algo = C.algo;
21 var EvpKDF = C_algo.EvpKDF;
22  
23 /**
24 * Abstract base cipher template.
25 *
26 * @property {number} keySize This cipher's key size. Default: 4 (128 bits)
27 * @property {number} ivSize This cipher's IV size. Default: 4 (128 bits)
28 * @property {number} _ENC_XFORM_MODE A constant representing encryption mode.
29 * @property {number} _DEC_XFORM_MODE A constant representing decryption mode.
30 */
31 var Cipher = C_lib.Cipher = BufferedBlockAlgorithm.extend({
32 /**
33 * Configuration options.
34 *
35 * @property {WordArray} iv The IV to use for this operation.
36 */
37 cfg: Base.extend(),
38  
39 /**
40 * Creates this cipher in encryption mode.
41 *
42 * @param {WordArray} key The key.
43 * @param {Object} cfg (Optional) The configuration options to use for this operation.
44 *
45 * @return {Cipher} A cipher instance.
46 *
47 * @static
48 *
49 * @example
50 *
51 * var cipher = CryptoJS.algo.AES.createEncryptor(keyWordArray, { iv: ivWordArray });
52 */
53 createEncryptor: function (key, cfg) {
54 return this.create(this._ENC_XFORM_MODE, key, cfg);
55 },
56  
57 /**
58 * Creates this cipher in decryption mode.
59 *
60 * @param {WordArray} key The key.
61 * @param {Object} cfg (Optional) The configuration options to use for this operation.
62 *
63 * @return {Cipher} A cipher instance.
64 *
65 * @static
66 *
67 * @example
68 *
69 * var cipher = CryptoJS.algo.AES.createDecryptor(keyWordArray, { iv: ivWordArray });
70 */
71 createDecryptor: function (key, cfg) {
72 return this.create(this._DEC_XFORM_MODE, key, cfg);
73 },
74  
75 /**
76 * Initializes a newly created cipher.
77 *
78 * @param {number} xformMode Either the encryption or decryption transormation mode constant.
79 * @param {WordArray} key The key.
80 * @param {Object} cfg (Optional) The configuration options to use for this operation.
81 *
82 * @example
83 *
84 * var cipher = CryptoJS.algo.AES.create(CryptoJS.algo.AES._ENC_XFORM_MODE, keyWordArray, { iv: ivWordArray });
85 */
86 init: function (xformMode, key, cfg) {
87 // Apply config defaults
88 this.cfg = this.cfg.extend(cfg);
89  
90 // Store transform mode and key
91 this._xformMode = xformMode;
92 this._key = key;
93  
94 // Set initial values
95 this.reset();
96 },
97  
98 /**
99 * Resets this cipher to its initial state.
100 *
101 * @example
102 *
103 * cipher.reset();
104 */
105 reset: function () {
106 // Reset data buffer
107 BufferedBlockAlgorithm.reset.call(this);
108  
109 // Perform concrete-cipher logic
110 this._doReset();
111 },
112  
113 /**
114 * Adds data to be encrypted or decrypted.
115 *
116 * @param {WordArray|string} dataUpdate The data to encrypt or decrypt.
117 *
118 * @return {WordArray} The data after processing.
119 *
120 * @example
121 *
122 * var encrypted = cipher.process('data');
123 * var encrypted = cipher.process(wordArray);
124 */
125 process: function (dataUpdate) {
126 // Append
127 this._append(dataUpdate);
128  
129 // Process available blocks
130 return this._process();
131 },
132  
133 /**
134 * Finalizes the encryption or decryption process.
135 * Note that the finalize operation is effectively a destructive, read-once operation.
136 *
137 * @param {WordArray|string} dataUpdate The final data to encrypt or decrypt.
138 *
139 * @return {WordArray} The data after final processing.
140 *
141 * @example
142 *
143 * var encrypted = cipher.finalize();
144 * var encrypted = cipher.finalize('data');
145 * var encrypted = cipher.finalize(wordArray);
146 */
147 finalize: function (dataUpdate) {
148 // Final data update
149 if (dataUpdate) {
150 this._append(dataUpdate);
151 }
152  
153 // Perform concrete-cipher logic
154 var finalProcessedData = this._doFinalize();
155  
156 return finalProcessedData;
157 },
158  
159 keySize: 128/32,
160  
161 ivSize: 128/32,
162  
163 _ENC_XFORM_MODE: 1,
164  
165 _DEC_XFORM_MODE: 2,
166  
167 /**
168 * Creates shortcut functions to a cipher's object interface.
169 *
170 * @param {Cipher} cipher The cipher to create a helper for.
171 *
172 * @return {Object} An object with encrypt and decrypt shortcut functions.
173 *
174 * @static
175 *
176 * @example
177 *
178 * var AES = CryptoJS.lib.Cipher._createHelper(CryptoJS.algo.AES);
179 */
180 _createHelper: (function () {
181 function selectCipherStrategy(key) {
182 if (typeof key == 'string') {
183 return PasswordBasedCipher;
184 } else {
185 return SerializableCipher;
186 }
187 }
188  
189 return function (cipher) {
190 return {
191 encrypt: function (message, key, cfg) {
192 return selectCipherStrategy(key).encrypt(cipher, message, key, cfg);
193 },
194  
195 decrypt: function (ciphertext, key, cfg) {
196 return selectCipherStrategy(key).decrypt(cipher, ciphertext, key, cfg);
197 }
198 };
199 };
200 }())
201 });
202  
203 /**
204 * Abstract base stream cipher template.
205 *
206 * @property {number} blockSize The number of 32-bit words this cipher operates on. Default: 1 (32 bits)
207 */
208 var StreamCipher = C_lib.StreamCipher = Cipher.extend({
209 _doFinalize: function () {
210 // Process partial blocks
211 var finalProcessedBlocks = this._process(!!'flush');
212  
213 return finalProcessedBlocks;
214 },
215  
216 blockSize: 1
217 });
218  
219 /**
220 * Mode namespace.
221 */
222 var C_mode = C.mode = {};
223  
224 /**
225 * Abstract base block cipher mode template.
226 */
227 var BlockCipherMode = C_lib.BlockCipherMode = Base.extend({
228 /**
229 * Creates this mode for encryption.
230 *
231 * @param {Cipher} cipher A block cipher instance.
232 * @param {Array} iv The IV words.
233 *
234 * @static
235 *
236 * @example
237 *
238 * var mode = CryptoJS.mode.CBC.createEncryptor(cipher, iv.words);
239 */
240 createEncryptor: function (cipher, iv) {
241 return this.Encryptor.create(cipher, iv);
242 },
243  
244 /**
245 * Creates this mode for decryption.
246 *
247 * @param {Cipher} cipher A block cipher instance.
248 * @param {Array} iv The IV words.
249 *
250 * @static
251 *
252 * @example
253 *
254 * var mode = CryptoJS.mode.CBC.createDecryptor(cipher, iv.words);
255 */
256 createDecryptor: function (cipher, iv) {
257 return this.Decryptor.create(cipher, iv);
258 },
259  
260 /**
261 * Initializes a newly created mode.
262 *
263 * @param {Cipher} cipher A block cipher instance.
264 * @param {Array} iv The IV words.
265 *
266 * @example
267 *
268 * var mode = CryptoJS.mode.CBC.Encryptor.create(cipher, iv.words);
269 */
270 init: function (cipher, iv) {
271 this._cipher = cipher;
272 this._iv = iv;
273 }
274 });
275  
276 /**
277 * Cipher Block Chaining mode.
278 */
279 var CBC = C_mode.CBC = (function () {
280 /**
281 * Abstract base CBC mode.
282 */
283 var CBC = BlockCipherMode.extend();
284  
285 /**
286 * CBC encryptor.
287 */
288 CBC.Encryptor = CBC.extend({
289 /**
290 * Processes the data block at offset.
291 *
292 * @param {Array} words The data words to operate on.
293 * @param {number} offset The offset where the block starts.
294 *
295 * @example
296 *
297 * mode.processBlock(data.words, offset);
298 */
299 processBlock: function (words, offset) {
300 // Shortcuts
301 var cipher = this._cipher;
302 var blockSize = cipher.blockSize;
303  
304 // XOR and encrypt
305 xorBlock.call(this, words, offset, blockSize);
306 cipher.encryptBlock(words, offset);
307  
308 // Remember this block to use with next block
309 this._prevBlock = words.slice(offset, offset + blockSize);
310 }
311 });
312  
313 /**
314 * CBC decryptor.
315 */
316 CBC.Decryptor = CBC.extend({
317 /**
318 * Processes the data block at offset.
319 *
320 * @param {Array} words The data words to operate on.
321 * @param {number} offset The offset where the block starts.
322 *
323 * @example
324 *
325 * mode.processBlock(data.words, offset);
326 */
327 processBlock: function (words, offset) {
328 // Shortcuts
329 var cipher = this._cipher;
330 var blockSize = cipher.blockSize;
331  
332 // Remember this block to use with next block
333 var thisBlock = words.slice(offset, offset + blockSize);
334  
335 // Decrypt and XOR
336 cipher.decryptBlock(words, offset);
337 xorBlock.call(this, words, offset, blockSize);
338  
339 // This block becomes the previous block
340 this._prevBlock = thisBlock;
341 }
342 });
343  
344 function xorBlock(words, offset, blockSize) {
345 // Shortcut
346 var iv = this._iv;
347  
348 // Choose mixing block
349 if (iv) {
350 var block = iv;
351  
352 // Remove IV for subsequent blocks
353 this._iv = undefined;
354 } else {
355 var block = this._prevBlock;
356 }
357  
358 // XOR blocks
359 for (var i = 0; i < blockSize; i++) {
360 words[offset + i] ^= block[i];
361 }
362 }
363  
364 return CBC;
365 }());
366  
367 /**
368 * Padding namespace.
369 */
370 var C_pad = C.pad = {};
371  
372 /**
373 * PKCS #5/7 padding strategy.
374 */
375 var Pkcs7 = C_pad.Pkcs7 = {
376 /**
377 * Pads data using the algorithm defined in PKCS #5/7.
378 *
379 * @param {WordArray} data The data to pad.
380 * @param {number} blockSize The multiple that the data should be padded to.
381 *
382 * @static
383 *
384 * @example
385 *
386 * CryptoJS.pad.Pkcs7.pad(wordArray, 4);
387 */
388 pad: function (data, blockSize) {
389 // Shortcut
390 var blockSizeBytes = blockSize * 4;
391  
392 // Count padding bytes
393 var nPaddingBytes = blockSizeBytes - data.sigBytes % blockSizeBytes;
394  
395 // Create padding word
396 var paddingWord = (nPaddingBytes << 24) | (nPaddingBytes << 16) | (nPaddingBytes << 8) | nPaddingBytes;
397  
398 // Create padding
399 var paddingWords = [];
400 for (var i = 0; i < nPaddingBytes; i += 4) {
401 paddingWords.push(paddingWord);
402 }
403 var padding = WordArray.create(paddingWords, nPaddingBytes);
404  
405 // Add padding
406 data.concat(padding);
407 },
408  
409 /**
410 * Unpads data that had been padded using the algorithm defined in PKCS #5/7.
411 *
412 * @param {WordArray} data The data to unpad.
413 *
414 * @static
415 *
416 * @example
417 *
418 * CryptoJS.pad.Pkcs7.unpad(wordArray);
419 */
420 unpad: function (data) {
421 // Get number of padding bytes from last byte
422 var nPaddingBytes = data.words[(data.sigBytes - 1) >>> 2] & 0xff;
423  
424 // Remove padding
425 data.sigBytes -= nPaddingBytes;
426 }
427 };
428  
429 /**
430 * Abstract base block cipher template.
431 *
432 * @property {number} blockSize The number of 32-bit words this cipher operates on. Default: 4 (128 bits)
433 */
434 var BlockCipher = C_lib.BlockCipher = Cipher.extend({
435 /**
436 * Configuration options.
437 *
438 * @property {Mode} mode The block mode to use. Default: CBC
439 * @property {Padding} padding The padding strategy to use. Default: Pkcs7
440 */
441 cfg: Cipher.cfg.extend({
442 mode: CBC,
443 padding: Pkcs7
444 }),
445  
446 reset: function () {
447 // Reset cipher
448 Cipher.reset.call(this);
449  
450 // Shortcuts
451 var cfg = this.cfg;
452 var iv = cfg.iv;
453 var mode = cfg.mode;
454  
455 // Reset block mode
456 if (this._xformMode == this._ENC_XFORM_MODE) {
457 var modeCreator = mode.createEncryptor;
458 } else /* if (this._xformMode == this._DEC_XFORM_MODE) */ {
459 var modeCreator = mode.createDecryptor;
460  
461 // Keep at least one block in the buffer for unpadding
462 this._minBufferSize = 1;
463 }
464 this._mode = modeCreator.call(mode, this, iv && iv.words);
465 },
466  
467 _doProcessBlock: function (words, offset) {
468 this._mode.processBlock(words, offset);
469 },
470  
471 _doFinalize: function () {
472 // Shortcut
473 var padding = this.cfg.padding;
474  
475 // Finalize
476 if (this._xformMode == this._ENC_XFORM_MODE) {
477 // Pad data
478 padding.pad(this._data, this.blockSize);
479  
480 // Process final blocks
481 var finalProcessedBlocks = this._process(!!'flush');
482 } else /* if (this._xformMode == this._DEC_XFORM_MODE) */ {
483 // Process final blocks
484 var finalProcessedBlocks = this._process(!!'flush');
485  
486 // Unpad data
487 padding.unpad(finalProcessedBlocks);
488 }
489  
490 return finalProcessedBlocks;
491 },
492  
493 blockSize: 128/32
494 });
495  
496 /**
497 * A collection of cipher parameters.
498 *
499 * @property {WordArray} ciphertext The raw ciphertext.
500 * @property {WordArray} key The key to this ciphertext.
501 * @property {WordArray} iv The IV used in the ciphering operation.
502 * @property {WordArray} salt The salt used with a key derivation function.
503 * @property {Cipher} algorithm The cipher algorithm.
504 * @property {Mode} mode The block mode used in the ciphering operation.
505 * @property {Padding} padding The padding scheme used in the ciphering operation.
506 * @property {number} blockSize The block size of the cipher.
507 * @property {Format} formatter The default formatting strategy to convert this cipher params object to a string.
508 */
509 var CipherParams = C_lib.CipherParams = Base.extend({
510 /**
511 * Initializes a newly created cipher params object.
512 *
513 * @param {Object} cipherParams An object with any of the possible cipher parameters.
514 *
515 * @example
516 *
517 * var cipherParams = CryptoJS.lib.CipherParams.create({
518 * ciphertext: ciphertextWordArray,
519 * key: keyWordArray,
520 * iv: ivWordArray,
521 * salt: saltWordArray,
522 * algorithm: CryptoJS.algo.AES,
523 * mode: CryptoJS.mode.CBC,
524 * padding: CryptoJS.pad.PKCS7,
525 * blockSize: 4,
526 * formatter: CryptoJS.format.OpenSSL
527 * });
528 */
529 init: function (cipherParams) {
530 this.mixIn(cipherParams);
531 },
532  
533 /**
534 * Converts this cipher params object to a string.
535 *
536 * @param {Format} formatter (Optional) The formatting strategy to use.
537 *
538 * @return {string} The stringified cipher params.
539 *
540 * @throws Error If neither the formatter nor the default formatter is set.
541 *
542 * @example
543 *
544 * var string = cipherParams + '';
545 * var string = cipherParams.toString();
546 * var string = cipherParams.toString(CryptoJS.format.OpenSSL);
547 */
548 toString: function (formatter) {
549 return (formatter || this.formatter).stringify(this);
550 }
551 });
552  
553 /**
554 * Format namespace.
555 */
556 var C_format = C.format = {};
557  
558 /**
559 * OpenSSL formatting strategy.
560 */
561 var OpenSSLFormatter = C_format.OpenSSL = {
562 /**
563 * Converts a cipher params object to an OpenSSL-compatible string.
564 *
565 * @param {CipherParams} cipherParams The cipher params object.
566 *
567 * @return {string} The OpenSSL-compatible string.
568 *
569 * @static
570 *
571 * @example
572 *
573 * var openSSLString = CryptoJS.format.OpenSSL.stringify(cipherParams);
574 */
575 stringify: function (cipherParams) {
576 // Shortcuts
577 var ciphertext = cipherParams.ciphertext;
578 var salt = cipherParams.salt;
579  
580 // Format
581 if (salt) {
582 var wordArray = WordArray.create([0x53616c74, 0x65645f5f]).concat(salt).concat(ciphertext);
583 } else {
584 var wordArray = ciphertext;
585 }
586  
587 return wordArray.toString(Base64);
588 },
589  
590 /**
591 * Converts an OpenSSL-compatible string to a cipher params object.
592 *
593 * @param {string} openSSLStr The OpenSSL-compatible string.
594 *
595 * @return {CipherParams} The cipher params object.
596 *
597 * @static
598 *
599 * @example
600 *
601 * var cipherParams = CryptoJS.format.OpenSSL.parse(openSSLString);
602 */
603 parse: function (openSSLStr) {
604 // Parse base64
605 var ciphertext = Base64.parse(openSSLStr);
606  
607 // Shortcut
608 var ciphertextWords = ciphertext.words;
609  
610 // Test for salt
611 if (ciphertextWords[0] == 0x53616c74 && ciphertextWords[1] == 0x65645f5f) {
612 // Extract salt
613 var salt = WordArray.create(ciphertextWords.slice(2, 4));
614  
615 // Remove salt from ciphertext
616 ciphertextWords.splice(0, 4);
617 ciphertext.sigBytes -= 16;
618 }
619  
620 return CipherParams.create({ ciphertext: ciphertext, salt: salt });
621 }
622 };
623  
624 /**
625 * A cipher wrapper that returns ciphertext as a serializable cipher params object.
626 */
627 var SerializableCipher = C_lib.SerializableCipher = Base.extend({
628 /**
629 * Configuration options.
630 *
631 * @property {Formatter} format The formatting strategy to convert cipher param objects to and from a string. Default: OpenSSL
632 */
633 cfg: Base.extend({
634 format: OpenSSLFormatter
635 }),
636  
637 /**
638 * Encrypts a message.
639 *
640 * @param {Cipher} cipher The cipher algorithm to use.
641 * @param {WordArray|string} message The message to encrypt.
642 * @param {WordArray} key The key.
643 * @param {Object} cfg (Optional) The configuration options to use for this operation.
644 *
645 * @return {CipherParams} A cipher params object.
646 *
647 * @static
648 *
649 * @example
650 *
651 * var ciphertextParams = CryptoJS.lib.SerializableCipher.encrypt(CryptoJS.algo.AES, message, key);
652 * var ciphertextParams = CryptoJS.lib.SerializableCipher.encrypt(CryptoJS.algo.AES, message, key, { iv: iv });
653 * var ciphertextParams = CryptoJS.lib.SerializableCipher.encrypt(CryptoJS.algo.AES, message, key, { iv: iv, format: CryptoJS.format.OpenSSL });
654 */
655 encrypt: function (cipher, message, key, cfg) {
656 // Apply config defaults
657 cfg = this.cfg.extend(cfg);
658  
659 // Encrypt
660 var encryptor = cipher.createEncryptor(key, cfg);
661 var ciphertext = encryptor.finalize(message);
662  
663 // Shortcut
664 var cipherCfg = encryptor.cfg;
665  
666 // Create and return serializable cipher params
667 return CipherParams.create({
668 ciphertext: ciphertext,
669 key: key,
670 iv: cipherCfg.iv,
671 algorithm: cipher,
672 mode: cipherCfg.mode,
673 padding: cipherCfg.padding,
674 blockSize: cipher.blockSize,
675 formatter: cfg.format
676 });
677 },
678  
679 /**
680 * Decrypts serialized ciphertext.
681 *
682 * @param {Cipher} cipher The cipher algorithm to use.
683 * @param {CipherParams|string} ciphertext The ciphertext to decrypt.
684 * @param {WordArray} key The key.
685 * @param {Object} cfg (Optional) The configuration options to use for this operation.
686 *
687 * @return {WordArray} The plaintext.
688 *
689 * @static
690 *
691 * @example
692 *
693 * var plaintext = CryptoJS.lib.SerializableCipher.decrypt(CryptoJS.algo.AES, formattedCiphertext, key, { iv: iv, format: CryptoJS.format.OpenSSL });
694 * var plaintext = CryptoJS.lib.SerializableCipher.decrypt(CryptoJS.algo.AES, ciphertextParams, key, { iv: iv, format: CryptoJS.format.OpenSSL });
695 */
696 decrypt: function (cipher, ciphertext, key, cfg) {
697 // Apply config defaults
698 cfg = this.cfg.extend(cfg);
699  
700 // Convert string to CipherParams
701 ciphertext = this._parse(ciphertext, cfg.format);
702  
703 // Decrypt
704 var plaintext = cipher.createDecryptor(key, cfg).finalize(ciphertext.ciphertext);
705  
706 return plaintext;
707 },
708  
709 /**
710 * Converts serialized ciphertext to CipherParams,
711 * else assumed CipherParams already and returns ciphertext unchanged.
712 *
713 * @param {CipherParams|string} ciphertext The ciphertext.
714 * @param {Formatter} format The formatting strategy to use to parse serialized ciphertext.
715 *
716 * @return {CipherParams} The unserialized ciphertext.
717 *
718 * @static
719 *
720 * @example
721 *
722 * var ciphertextParams = CryptoJS.lib.SerializableCipher._parse(ciphertextStringOrParams, format);
723 */
724 _parse: function (ciphertext, format) {
725 if (typeof ciphertext == 'string') {
726 return format.parse(ciphertext, this);
727 } else {
728 return ciphertext;
729 }
730 }
731 });
732  
733 /**
734 * Key derivation function namespace.
735 */
736 var C_kdf = C.kdf = {};
737  
738 /**
739 * OpenSSL key derivation function.
740 */
741 var OpenSSLKdf = C_kdf.OpenSSL = {
742 /**
743 * Derives a key and IV from a password.
744 *
745 * @param {string} password The password to derive from.
746 * @param {number} keySize The size in words of the key to generate.
747 * @param {number} ivSize The size in words of the IV to generate.
748 * @param {WordArray|string} salt (Optional) A 64-bit salt to use. If omitted, a salt will be generated randomly.
749 *
750 * @return {CipherParams} A cipher params object with the key, IV, and salt.
751 *
752 * @static
753 *
754 * @example
755 *
756 * var derivedParams = CryptoJS.kdf.OpenSSL.execute('Password', 256/32, 128/32);
757 * var derivedParams = CryptoJS.kdf.OpenSSL.execute('Password', 256/32, 128/32, 'saltsalt');
758 */
759 execute: function (password, keySize, ivSize, salt) {
760 // Generate random salt
761 if (!salt) {
762 salt = WordArray.random(64/8);
763 }
764  
765 // Derive key and IV
766 var key = EvpKDF.create({ keySize: keySize + ivSize }).compute(password, salt);
767  
768 // Separate key and IV
769 var iv = WordArray.create(key.words.slice(keySize), ivSize * 4);
770 key.sigBytes = keySize * 4;
771  
772 // Return params
773 return CipherParams.create({ key: key, iv: iv, salt: salt });
774 }
775 };
776  
777 /**
778 * A serializable cipher wrapper that derives the key from a password,
779 * and returns ciphertext as a serializable cipher params object.
780 */
781 var PasswordBasedCipher = C_lib.PasswordBasedCipher = SerializableCipher.extend({
782 /**
783 * Configuration options.
784 *
785 * @property {KDF} kdf The key derivation function to use to generate a key and IV from a password. Default: OpenSSL
786 */
787 cfg: SerializableCipher.cfg.extend({
788 kdf: OpenSSLKdf
789 }),
790  
791 /**
792 * Encrypts a message using a password.
793 *
794 * @param {Cipher} cipher The cipher algorithm to use.
795 * @param {WordArray|string} message The message to encrypt.
796 * @param {string} password The password.
797 * @param {Object} cfg (Optional) The configuration options to use for this operation.
798 *
799 * @return {CipherParams} A cipher params object.
800 *
801 * @static
802 *
803 * @example
804 *
805 * var ciphertextParams = CryptoJS.lib.PasswordBasedCipher.encrypt(CryptoJS.algo.AES, message, 'password');
806 * var ciphertextParams = CryptoJS.lib.PasswordBasedCipher.encrypt(CryptoJS.algo.AES, message, 'password', { format: CryptoJS.format.OpenSSL });
807 */
808 encrypt: function (cipher, message, password, cfg) {
809 // Apply config defaults
810 cfg = this.cfg.extend(cfg);
811  
812 // Derive key and other params
813 var derivedParams = cfg.kdf.execute(password, cipher.keySize, cipher.ivSize);
814  
815 // Add IV to config
816 cfg.iv = derivedParams.iv;
817  
818 // Encrypt
819 var ciphertext = SerializableCipher.encrypt.call(this, cipher, message, derivedParams.key, cfg);
820  
821 // Mix in derived params
822 ciphertext.mixIn(derivedParams);
823  
824 return ciphertext;
825 },
826  
827 /**
828 * Decrypts serialized ciphertext using a password.
829 *
830 * @param {Cipher} cipher The cipher algorithm to use.
831 * @param {CipherParams|string} ciphertext The ciphertext to decrypt.
832 * @param {string} password The password.
833 * @param {Object} cfg (Optional) The configuration options to use for this operation.
834 *
835 * @return {WordArray} The plaintext.
836 *
837 * @static
838 *
839 * @example
840 *
841 * var plaintext = CryptoJS.lib.PasswordBasedCipher.decrypt(CryptoJS.algo.AES, formattedCiphertext, 'password', { format: CryptoJS.format.OpenSSL });
842 * var plaintext = CryptoJS.lib.PasswordBasedCipher.decrypt(CryptoJS.algo.AES, ciphertextParams, 'password', { format: CryptoJS.format.OpenSSL });
843 */
844 decrypt: function (cipher, ciphertext, password, cfg) {
845 // Apply config defaults
846 cfg = this.cfg.extend(cfg);
847  
848 // Convert string to CipherParams
849 ciphertext = this._parse(ciphertext, cfg.format);
850  
851 // Derive key and other params
852 var derivedParams = cfg.kdf.execute(password, cipher.keySize, cipher.ivSize, ciphertext.salt);
853  
854 // Add IV to config
855 cfg.iv = derivedParams.iv;
856  
857 // Decrypt
858 var plaintext = SerializableCipher.decrypt.call(this, cipher, ciphertext, derivedParams.key, cfg);
859  
860 return plaintext;
861 }
862 });
863 }());