ing-web-es 1.0.0

package/start.ingbusiness.pl/scripts/login-app.js

@@ -0,0 +1,107 @@
+'use strict';
+
+angular.module('commons', []);
+angular.module('converters', []);
+angular.module('ingbolDirectives', []);
+
+angular.module('validation', ['commons', 'converters']);
+
+var loginApp = angular.module('loginApp', ['ingbolDirectives', 'ui.router.state', 'pascalprecht.translate', 'commons', 'ngCookies', 'validation']);
+
+loginApp.service('httpRequestInterceptor', ['$q', '$injector', function($q, $injector) {
+    var handlers = [];
+    handlers[401] = handlers[403] = handlers[404] = 'maintenance';
+    handlers[500] = handlers[503] = 'error';
+
+    function handleError(response) {
+        // workaround for error: "Circular dependency found: $state"
+        var $state = $injector.get("$state");
+
+        if (response instanceof Error) {
+            $state.go('maintenance');
+        } else if (response && response.status) {
+            var statusHandlerState = handlers[response.status];
+            if (statusHandlerState) {
+                if (response.config.url && response.config.url.indexOf("maintenance.html") > -1) {
+                    // error in retrieving error page, reload to avoid furhter tries
+                    location.reload();
+                }
+                $state.go(statusHandlerState);
+            }
+        }
+    }
+
+    return {
+        requestError: function(request) {
+            return $q.reject(request);
+        },
+        response: function(response) {
+            if (response && response.data && response.data.errors && response.data.errors.length > 0) {
+                var $state = $injector.get("$state");
+                $state.go('customError', {
+                    errors: response.data.errors
+                });
+                return $q.reject(response);
+            }
+            return response || $q.when(response);
+        },
+        responseError: function(response) {
+            handleError(response);
+            return $q.reject(response);
+        }
+    };
+}]);
+
+loginApp.config(['$translateProvider', '$httpProvider', '$qProvider', '$compileProvider', function($translateProvider, $httpProvider, $qProvider, $compileProvider) {
+    $translateProvider.preferredLanguage('pl');
+    // sanitize nie działa z UTF-8: https://stackoverflow.com/questions/31002499/angular-translate-sanitisation-fails-with-utf-characters https://github.com/angular-translate/angular-translate/issues/1101
+    $translateProvider.useSanitizeValueStrategy('escape');
+    $httpProvider.interceptors.push('httpRequestInterceptor');
+    $qProvider.errorOnUnhandledRejections(false);
+
+    $compileProvider.aHrefSanitizationWhitelist(/^\s*(https?|ftp|mailto|tel|file|blob):/);
+    $compileProvider.debugInfoEnabled(false);
+    $compileProvider.commentDirectivesEnabled(false);
+    $compileProvider.cssClassDirectivesEnabled(false);
+}]);
+
+loginApp.run(['$state', '$rootScope', '$log', '$window', 'userAgentResolverService', function($state, $rootScope, $log, $window, userAgentResolverService) {
+    $rootScope.state = $state;
+    $rootScope.userAgentResolverService = userAgentResolverService;
+
+    $rootScope.$on('$stateChangeStart', function(event, toState) {
+        $log.log('Changing state to ' + toState.name);
+        if (toState.externalUrl) {
+
+            $window.open(toState.externalUrl, '_self');
+            if (toState.params) {
+                sessionStorage.setItem('loginParams', JSON.stringify(toState.params));
+            }
+        }
+    });
+
+    $rootScope.$on('$stateChangeError', function(event, toState) {
+        $log.error('Error during changing state to ' + toState.name);
+    });
+
+    $rootScope.$on('$stateChangeSuccess', function(event, toState, toParams, fromState, fromParams) {
+        $log.log('Changed state to ' + toState.name);
+        if (toParams.gemiusState) {
+            gemius_event('_view_', getGemiusID(), 'nazwa_strony=' + gemiusStates[toParams.gemiusState]);
+        }
+    });
+
+    $rootScope.$on('$viewContentLoaded', function(event) {
+        $log.log('DOM rendered: ' + event);
+    });
+
+    $rootScope.$on('$stateNotFound', function(event, unfoundState, fromState) {
+        $log.log('State not found: ' + unfoundState.to + ' (from: ' + fromState.name + ')');
+    });
+}]);
+
+window.onload = function() {
+    angular.bootstrap(document, ['loginApp'], {
+        strictDi: true
+    });
+};

package/start.ingbusiness.pl/scripts/login-en.js

@@ -0,0 +1,73 @@
+loginApp.config(['$translateProvider', function($translateProvider) {
+    $translateProvider.translations('en', {
+        HEADER: {
+            PAGE_TITLE: 'ING Business'
+        },
+        FORMS: {
+            TITLE: 'Login',
+            TITLE_OOBA: 'Confirm login in mobile app',
+            LOGIN: 'Enter your login',
+            LOGIN_LABEL: 'Create a new password for the login: ',
+            PASSWORD_FOR_LOGIN: 'Enter the password characters indicated for the login: ',
+            FIRST_LOGIN: 'Help with logging in',
+            FORGOT_LOGIN: 'Forgot my login',
+            UNLOCK: 'Forgot my password',
+            NEXT: 'Next',
+            SMS: 'Type SMS code no. {{smsNumber}} for login',
+            NEW_PASSWORD: 'New password',
+            REPEAT_PASSWORD: 'Repeat password',
+            ERROR_LOGIN: 'Unsuccessful login to ING Business',
+            BACK_TO_LOGIN: 'Back to login page',
+            BACK_TO_LOGIN_LINK: 'Go back to login page',
+            UNLOCK_USER: {
+                TITLE: 'Forgot my password',
+                NEXT: 'Send password'
+            },
+            UNLOCK_USER_RESULT: {
+                TITLE: 'We\'ve sent you a new password'
+            },
+            HELP: 'Help',
+            CRITICAL_MESSAGE: {
+                MORE_BUTTON: 'More'
+            },
+            NIP_REGON: 'Enter NIP or REGON',
+            MOBILE_AUTH: {
+                OPEN_MOBILE_APP_LINE1a: 'Login to ',
+                OPEN_MOBILE_APP_LINE1b: 'ING Business mobile app',
+                OPEN_MOBILE_APP_LINE2a: 'and make sure you see ',
+                OPEN_MOBILE_APP_LINE2b: 'the same image as below',
+                PREFER_SMS: 'I prefer to type in my password and confirm login with SMS code ',
+                SEND_SMS: 'Go to password input',
+                REMAINING_TIME: 'Remaining ',
+                REMAINING_TIME_SEC: ' sec.'
+            }
+        },
+        PASSWORD_STRENGTH: {
+            WEAK: 'weak',
+            MEDIUM: 'medium',
+            STRONG: 'strong'
+        },
+        ERRORS: {
+            ALIAS_REQUIRED: 'Enter your ING Business login',
+            PASSWORD_REQUIRED: 'Please fill in all fields',
+            INVALID_CODE: 'Incorrect SMS password',
+            INCORRECT_REPEAT: 'Your input does not match your new password',
+            POLICY_RULES: 'Password does not meet security policy rules',
+            CHANGE_PASSWORD_DISTINCT: 'You cannot repeat any of {{pswDistinct}} previous passwords',
+            NIP_REGON_REQUIRED: 'Enter NIP or REGON',
+            NIP_REGON_NOT_VALID: 'Enter valid NIP or REGON'
+        },
+        OTHER: {
+            KEYBOARD: 'On-screen keyboard',
+            BACK: 'Back',
+            DESKTOP_VERSION: 'desktop version',
+            TABLET_VERSION: 'tablet version'
+        },
+        COOKIES: {
+            CLOSE: 'Close',
+            INFO_1: 'This site uses cookie files.',
+            INFO_2: 'More information about cookies, their use and how to modify the acceptance of cookies can be found at',
+            INFO_3: 'Cookie policy.'
+        }
+    });
+}]);

package/start.ingbusiness.pl/scripts/login-pl.js

@@ -0,0 +1,74 @@
+loginApp.config(['$translateProvider', function($translateProvider) {
+    $translateProvider.translations('pl', {
+        HEADER: {
+            PAGE_TITLE: 'ING Business'
+        },
+        FORMS: {
+            TITLE: 'Logowanie',
+            TITLE_OOBA: 'Potwierdź logowanie w aplikacji mobilnej',
+            LOGIN: 'Wpisz swój login',
+            LOGIN_LABEL: 'Utwórz nowe hasło dla loginu: ',
+            PASSWORD_FOR_LOGIN: 'Wpisz wskazane znaki hasła dla loginu: ',
+            FIRST_LOGIN: 'Pomoc w logowaniu',
+            FORGOT_LOGIN: 'Nie pamiętam loginu',
+            UNLOCK: 'Nie pamiętam hasła',
+            NEXT: 'Dalej',
+            SMS: 'Wpisz kod SMS nr {{smsNumber}} dla loginu',
+            NEW_PASSWORD: 'Nowe hasło',
+            REPEAT_PASSWORD: 'Powtórz hasło',
+            ERROR_LOGIN: 'Nie udało się zalogować do ING Business',
+            BACK_TO_LOGIN: 'Powrót do logowania',
+            BACK_TO_LOGIN_LINK: 'Wróć do logowania',
+            UNLOCK_USER: {
+                TITLE: 'Nie pamiętam hasła',
+                NEXT: 'Wyślij hasło'
+            },
+            UNLOCK_USER_RESULT: {
+                TITLE: 'Wysłaliśmy hasło startowe'
+            },
+            HELP: 'Pomoc',
+            CRITICAL_MESSAGE: {
+                MORE_BUTTON: 'Więcej'
+            },
+            NIP_REGON: 'Wpisz NIP lub REGON',
+            MOBILE_AUTH: {
+                OPEN_MOBILE_APP_LINE1a: 'Zaloguj się ',
+                OPEN_MOBILE_APP_LINE1b: 'do aplikacji mobilnej ING Business',
+                OPEN_MOBILE_APP_LINE2a: 'i upewnij się, że ',
+                OPEN_MOBILE_APP_LINE2b: 'obrazki są takie same',
+                PREFER_SMS: 'Wolę podać swoje hasło i potwierdzić logowanie kodem SMS ',
+                SEND_SMS: 'Przejdź do podania hasła',
+                REMAINING_TIME: 'Zostało ',
+                REMAINING_TIME_SEC: ' sek.'
+            }
+        },
+        PASSWORD_STRENGTH: {
+            WEAK: 'słabe',
+            MEDIUM: 'średnie',
+            STRONG: 'silne'
+        },
+        ERRORS: {
+            ALIAS_REQUIRED: 'Wpisz swój login do ING Business',
+            PASSWORD_REQUIRED: 'Uzupełnij wskazane pola',
+            INVALID_CODE: 'Błędny kod SMS',
+            INCORRECT_REPEAT: 'Niepoprawne powtórzenie nowego hasła',
+            POLICY_RULES: 'Hasło nie spełnia reguł polityki bezpieczeństwa',
+            CHANGE_PASSWORD_DISTINCT: 'Nowe hasło musi być różne od {{pswDistinct}} poprzednich',
+            NIP_REGON_REQUIRED: 'Wpisz NIP lub REGON',
+            NIP_REGON_NOT_VALID: 'Wpisz poprawny NIP lub REGON'
+        },
+        OTHER: {
+            KEYBOARD: 'Klawiatura ekranowa',
+            BACK: 'Wstecz',
+            DESKTOP_VERSION: 'wersja klasyczna',
+            TABLET_VERSION: 'wersja tabletowa'
+        },
+        COOKIES: {
+            CLOSE: 'Zamknij',
+            INFO_1: 'Ta witryna używa plików cookie.',
+            INFO_2: 'Więcej informacji o używanych przez nas plikach cookie, ich zastosowaniu i sposobie modyfikacji akceptacji plików cookie,' +
+                ' można znaleźć na stronie',
+            INFO_3: 'Polityka plików cookie.'
+        }
+    });
+}]);

package/start.ingbusiness.pl/scripts/login-states.js

@@ -0,0 +1,156 @@
+'use strict';
+
+loginApp.config(['$stateProvider', 'psd2State', function($stateProvider, psd2State) {
+
+    var aliasState = {
+        templateUrl: 'alias/form.html?v=202110040949',
+        controller: 'AliasCtrl',
+        params: {
+            navLinks: {
+                showFirstLogin: true,
+                showForgotLogin: true,
+                showUnlock: true,
+                gemiusParamMiejsce: 'ekrany_logowania_login'
+            },
+            gemiusState: 'loginAlias'
+        }
+    };
+
+    var aliasStateUrl = angular.copy(aliasState);
+    aliasStateUrl.url = '';
+    // workaround for redundant hash in url
+    $stateProvider.state('default', aliasStateUrl);
+
+    var psd2AliasState = angular.copy(aliasState);
+    psd2AliasState.controller = 'Psd2AliasCtrl';
+    psd2AliasState.url = '/PSD2/:psd2SessionId';
+
+    $stateProvider.state('alias', aliasState);
+
+    $stateProvider.state('psd2Alias', psd2AliasState);
+
+    $stateProvider.state('password', {
+        templateUrl: 'password/form.html?v=202110040949',
+        controller: 'PasswordCtrl',
+        params: {
+            loginMask: '',
+            mask: [],
+            maskLength: 0,
+            alias: '',
+            navLinks: {
+                showFirstLogin: true,
+                showForgotLogin: true,
+                showUnlock: true,
+                gemiusParamMiejsce: 'ekrany_logowania_haslo'
+            },
+            gemiusState: 'maskLogin'
+        }
+    });
+
+    $stateProvider.state('changePassword', {
+        resolve: {
+            settings: ['loginService', function(loginService) {
+                return loginService.getPasswordSecurityPolicy();
+            }]
+        },
+        templateUrl: 'change/form.html?v=202110040949',
+        controller: 'ChangePasswordCtrl',
+        params: {
+            alias: '',
+            navLinks: {
+                showFirstLogin: true,
+                gemiusParamMiejsce: 'ekrany_logowania_pierwsze_logowanie_podaj_haslo'
+            },
+            gemiusState: 'changePassword'
+        }
+    });
+
+    $stateProvider.state('sms', {
+        templateUrl: 'sms/form.html?v=202110040949',
+        controller: 'SmsCtrl',
+        params: {
+            alias: '',
+            textToSign: '',
+            smsDailyNumber: 0,
+            smsReasonForGemius: '',
+            navLinks: {
+                showFirstLogin: true,
+                gemiusParamMiejsce: 'ekrany_logowania_podaj_sms'
+            },
+            gemiusState: 'smsAuthorization'
+        }
+    });
+
+    $stateProvider.state('unlockUser', {
+        url: '/unlockUser',
+        templateUrl: 'unlock-user/form.html?v=202110040949',
+        controller: 'UnlockUserCtrl',
+        params: {
+            gemiusState: 'unlockUser'
+        }
+    });
+
+    $stateProvider.state('error', {
+        templateUrl: 'error/form.html?v=202110040949',
+        controller: 'ErrorCtrl',
+        params: {
+            navLinks: {
+                showUnlock: true,
+                gemiusParamMiejsce: 'ekrany_logowania_blad_logowania'
+            },
+            gemiusState: 'loginError'
+        }
+    });
+
+    $stateProvider.state('customError', {
+        templateUrl: 'custom-error/form.html?v=202110040949',
+        controller: 'CustomErrorCtrl',
+        params: {
+            errors: [],
+            gemiusState: 'loginError'
+        }
+    });
+
+    $stateProvider.state('maintenance', {
+        templateUrl: 'maintenance.html?v=202110040949'
+    });
+
+    $stateProvider.state('index', {
+        externalUrl: '../index.jsp'
+    });
+
+    $stateProvider.state('mobileAuth', {
+        templateUrl: 'mobile-auth/form.html?v=202110040949',
+        controller: 'mobileAuthCtrl',
+        params: {
+            loginMask: '',
+            mask: [],
+            maskLength: 0,
+            alias: '',
+            timerOoba: 0,
+            frequencyTimer: 0,
+            gemiusState: 'mobileAuthorization',
+            pid: ''
+        },
+        resolve: {
+            previousState: ["$state", function($state) {
+                return {
+                    name: $state.current.name,
+                    params: $state.params,
+                    URL: $state.href($state.current.name, $state.params)
+                };
+            }]
+        }
+    });
+
+    for (var property in psd2State) {
+        if (psd2State.hasOwnProperty(property)) {
+            var stateData = psd2State[property];
+            $stateProvider.state(stateData.state, {
+                externalUrl: stateData.externalUrl,
+                params: stateData.params
+            });
+        }
+    }
+
+}]);

package/start.ingbusiness.pl/scripts/maskService.js

@@ -0,0 +1,194 @@
+'use strict';
+
+angular.module('commons').service('maskService', ['hashService', 'maskUtilService', function(hashService, maskUtilService) {
+
+    // liczba masek (parametr)
+    var maskCount;
+    // tablica masek (MASK w postaci heksadecymalnej)
+    var masks = [];
+    // tablica zamaskowanych hasel (PASSMASKED' w
+    // postaci heksadecymalnej)
+    var passwords = [];
+    // tablica sum kwadratow indeksow niezamaskowanych
+    // pol dla kazdej maski
+    var powers = [];
+    // tablica dlugosci masek
+    var lengths = [];
+    // tablica skrotow SHA1(PASS+ALIAS) dla kazdego
+    // aliasu w postaci heksadecymalnej (modyfikacja
+    // hasla)
+    var sha1Passwords = [];
+    var maskChar = 5;
+
+    this.init = function(parameters) {
+        maskCount = parameters.maskCount;
+        maskChar = parameters.maskChar;
+    };
+
+    this.getMasks = function(newPassword, aliases) {
+        lengths.length = 0;
+        powers.length = 0;
+        masks.length = 0;
+        passwords.length = 0;
+        sha1Passwords.length = 0;
+
+        // wygenerowanie masek
+        for (var i = 0; i < maskCount; i++) {
+            var mask = this.createRandomMask(newPassword);
+            masks[i] = maskUtilService.arrayOfBytes2HexString(mask);
+        }
+
+        // wygenerowanie PASSMASKED' i HASH(PASS+ALIAS)
+        // dla kazdego aliasu
+        for (i = 0; i < aliases.length; i++) {
+            sha1Passwords[i] = hashService.calculateSHA1(newPassword + aliases[i]);
+
+            for (var j = 0; j < maskCount; j++) {
+                passwords[passwords.length] = maskUtilService.createPassMaskedBis(aliases[i], newPassword, maskUtilService.hexString2ArrayOfBytes(masks[j]));
+            }
+        }
+
+        return {
+            p_masks: masks.join(','),
+            p_passwords: passwords.join(','),
+            p_sha1_passwords: sha1Passwords.join(',')
+        };
+    };
+
+    // Funkcja na podstawie przekazanej maski tworzy
+    // tablice indeksow, ktore moga
+    // byc jeszcze wylosowane. Funkcja uwzglednia
+    // trywialnosc maski.
+    // Dopuszczalna liczba sasiadujacych pol
+    // niezamskowanych wynosi 3.
+    // Array mask1 - maska
+    this.createPossibleValueList = function(mask1) {
+        var mask2 = [];
+        maskUtilService.copyArray(mask1, mask2);
+
+        for (var i = 0; i < mask1.length - 3; i++) {
+            // pole zamaskowane
+            if (mask1[i] !== 0xFF) {
+                // trzy kolejne pola sa jedynkami
+                if (mask1[i + 1] === 0xFF && mask1[i + 2] === 0xFF && mask1[i + 3] === 0xFF) {
+                    mask2[i] = -1;
+                }
+            } else {
+                // pole niezamaskowane
+                if (mask1[i + 1] === 0xFF && mask1[i + 2] === 0xFF && mask1[i + 3] !== 0xFF) {
+                    mask2[i + 3] = -1;
+                } else if (mask1[i + 2] === 0xFF && mask1[i + 3] === 0xFF && mask1[i + 1] !== 0xFF) {
+                    mask2[i + 1] = -1;
+                } else if (mask1[i + 1] === 0xFF && mask1[i + 3] === 0xFF && mask1[i + 2] !== 0xFF) {
+                    mask2[i + 2] = -1;
+                }
+            }
+        }
+
+        var possVal = [];
+        for (i = 0; i < mask2.length; i++) {
+            if (mask2[i] !== 0xFF && mask2[i] !== -1) {
+                possVal[possVal.length] = i;
+            }
+        }
+
+        if (possVal.length === 0) {
+            return -1;
+        } else {
+            return possVal;
+        }
+    };
+
+    // Funkcja sprawdza czy maska jest unikalna
+    // Integer length1 - liczba niezamaskowanych pol
+    // Integer sum1 - suma kwadratow indeksow
+    // niezamaskowanych pol
+    this.isUniqueMask = function(length1, sum1) {
+        for (var i = 0; i < masks.length; i++) {
+            if (length1 === lengths[i] && sum1 === powers[i]) {
+                return false;
+            }
+        }
+
+        return true;
+    };
+
+    // Funkcja zwraca losowa, dopuszczalna liczbe
+    // niezamaskowanym pol w masce
+    // Liczba ta jest z przedzialu <4, pass.length - 5>
+    // String pass1 - haslo
+    this.getMaskFieldsCount = function() {
+        return maskChar;
+    };
+
+    // Funkcja tworzy tablice (maske) o rozmiarze rownym
+    // dlugosci hasla i wypelnia ja
+    // losowymi bajtami roznymi od 0xFF
+    // Integer len - dlugosc hasla
+    this.createEmptyMask = function(len) {
+        var emptyMask = [];
+        for (var i = 0; i < len; i++) {
+            emptyMask.push(maskUtilService.rand(254));
+        }
+
+        return emptyMask;
+    };
+
+    // Funkcja generuje pseudolosowa, niepowtarzalna i
+    // nietrywialna maske o pseudolosowej dlugosci.
+    // Obcina maske za ostatnim niezamaskowanym polem.
+    // String pass1 - haslo
+    this.createRandomMask = function(pass1) {
+        // maska
+        var mask = [];
+        // suma kwadratow indeksow
+        var sum = 0;
+        // liczba niezamaskowanych pol
+        var maskFieldsCount = 0;
+
+        // wygenerowanie niepowtarzalnej i nietrywialnej
+        // maski
+        do {
+            // utworzenie maski wypelnionej losowymi
+            // bajtami roznymi od 0xFF
+            mask = this.createEmptyMask(pass1.length);
+            // wylosowanie dlugosci maski
+            maskFieldsCount = this.getMaskFieldsCount(pass1);
+            // ustawienie tej zmiennej oznacza, ze nie
+            // da sie wygenerowac maski
+            var impas = false;
+            // wyzerowanie sumy kwadratow
+            sum = 0;
+
+            var possibleValues = this.createPossibleValueList(mask);
+
+            for (var i = 0; i < maskFieldsCount; i++) {
+                var randValue = maskUtilService.randArrayValue(possibleValues);
+                mask[randValue] = 0xFF;
+                possibleValues = this.createPossibleValueList(mask);
+                if (possibleValues === -1) {
+                    impas = true;
+                    break;
+                }
+                sum += maskUtilService.power(randValue);
+            }
+            if (impas) {
+                continue;
+            }
+        } while (!this.isUniqueMask(maskFieldsCount, sum));
+
+        // obciecie maski za ostatnim niezamaskowanym
+        // polem
+        while (mask[mask.length - 1] !== 0xFF) {
+            mask.length = mask.length - 1;
+        }
+
+        // wstawienie dlugosci i sumy do tablic
+        // globalnych
+        lengths[lengths.length] = maskFieldsCount;
+        powers[powers.length] = sum;
+
+        return mask;
+    };
+
+}]);