Code coverage report for src/utils/CryptUtils.ts

# All files / src/utils CryptUtils.ts

98% Statements 49/50
90% Branches 9/10
100% Functions 2/2
98% Lines 49/50

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    1211x
    1x

    1x

    141x

    141x

    141x
    1612x

    141x

    4928x

    4928x

    4928x

    141x

    5x

    5x
    5x
    5x
    5x

    5x
    398x
    192x

    206x

    5x

    5x

    5x

    5x

    5x
    5x

    5x

    138x
    138x
    138x
    138x

    138x
    35328x

    138x
    35328x
    35328x
    35328x
    35328x

    138x
    138x

    138x
    715x
    715x
    715x
    715x
    715x
    715x

    138x

     import { RandomGeneratorUtils } from './RandomGeneratorUtils';
    import { Utils } from './Utils';

    export class CryptUtils {
        /**
         * @param string
         */
        /* tslint:disable */
        public static btoa (string: string): string {
            const chars: string = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';

            let output: string = '';

            string = encodeURIComponent(string).replace(/%([0-9A-F]{2})/g, (match, p1) => {
                return String.fromCharCode(parseInt(`${Utils.hexadecimalPrefix}${p1}`));
            });

            for (
                let block: number|undefined, charCode: number, idx: number = 0, map: string = chars;
                string.charAt(idx | 0) || (map = '=', idx % 1);
                output += map.charAt(63 & block >> 8 - idx % 1 * 8)
            ) {
                charCode = string.charCodeAt(idx += 3/4);

                Iif (charCode > 0xFF) {
                    throw new Error("'btoa' failed: The string to be encoded contains characters outside of the Latin1 range.");
                }

                block = block << 8 | charCode;
            }

            return output;
        }
        /* tslint:enable */

        /**
         * @param str
         * @param length
         * @returns {string[]}
         */
        public static hideString (str: string, length: number): [string, string] {
            const escapeRegExp: (s: string) => string = (s: string) =>
                s.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');

            const randomMerge: (s1: string, s2: string) => string = function (s1: string, s2: string): string {
                let i1: number = -1,
                    i2: number = -1,
                    result: string = '';

                while (i1 < s1.length || i2 < s2.length) {
                    if (RandomGeneratorUtils.getMathRandom() < 0.5 && i2 < s2.length) {
                        result += s2.charAt(++i2);
                    } else {
                        result += s1.charAt(++i1);
                    }
                }

                return result;
            };

            const randomString: string = RandomGeneratorUtils.getRandomGenerator().string({
                length: length,
                pool: RandomGeneratorUtils.randomGeneratorPool
            });

            let randomStringDiff: string = randomString.replace(
                new RegExp('[' + escapeRegExp(str) + ']', 'g'),
                '');

            const randomStringDiffArray: string[] = randomStringDiff.split('');

            RandomGeneratorUtils.getRandomGenerator().shuffle(randomStringDiffArray);
            randomStringDiff = randomStringDiffArray.join('');

            return [randomMerge(str, randomStringDiff), randomStringDiff];

        }

        /**
         * RC4 symmetric cipher encryption/decryption
         * https://gist.github.com/farhadi/2185197
         *
         * @param key
         * @param string
         * @returns {string}
         */
        /* tslint:disable */
        public static rc4 (string: string, key: string): string {
            let s: number[] = [],
                j: number = 0,
                x: number,
                result: string = '';

            for (var i = 0; i < 256; i++) {
                s[i] = i;
            }

            for (i = 0; i < 256; i++) {
                j = (j + s[i] + key.charCodeAt(i % key.length)) % 256;
                x = s[i];
                s[i] = s[j];
                s[j] = x;
            }

            i = 0;
            j = 0;

            for (let y = 0; y < string.length; y++) {
                i = (i + 1) % 256;
                j = (j + s[i]) % 256;
                x = s[i];
                s[i] = s[j];
                s[j] = x;
                result += String.fromCharCode(string.charCodeAt(y) ^ s[(s[i] + s[j]) % 256]);
            }

            return result;
        }
        /* tslint:enable */
    }