corporate business

documentation technical

Russian

advcake_track_url

dSesn

_userGUID

_gid

_dvs

_ga_3KKBXY6RM3

tmr_detect

advcake_session_id

popmechanic_sbjs_migrations

_ym_isad

_dc_gtm_UA-35864216-1

domain_sid

_ym_d

tmr_lvidTS

_ym_visorc

directCrm-session

kotofoto

tmr_lvid

is_authorized

_ym_uid

mindboxDeviceUUID

You're looking at domain 'kotofoto.ru' on the Russian country-code top-level domain (.ru) and has no subdomain. Its registrable label 'kotofoto' stretches across 8 characters split between four vowels and four consonants. Splitting it apart reveals two words: koto, foto. The median word length lands at 4 characters. No strong language cues emerged from the frequency lists.

html/09/9c/099cf116-c3a7-492b-9db9-c9a499be16ff.html.gz

require-trusted-types-for 'script'; report-uri https://csp.withgoogle.com/csp/apps-themes

9243b4cca38525ff4d864eaa87d446d27950e248f84396b8cdda34649c6622fa

1da27fd5592ff7d4750cfe765d5ea8b2bca82af42858691993670b242332baf7

6b6de0d4db7876d1183a3edb47ebd3bbbf93f153f5de1ba6645049348628109a

fa09d9af0cd8d1abbbe8ca82f475d123b77b70b7fc9e8483afb1b0a41871e4c9

d4f243d8267dc8e86cea10d5d19f44baf6993f80d45c1d5bfd1b5460fbf35eba

716a77da7b26ce80cb005787563043b58638f2172e575e1d2fa2340b62b1d1c8

d35637aa15bf4e31b000ed30ea69309d05551ad540b5d0947be6f12867e23de4

0c7178cc6ca34fb18e30f070a5e7a1c287b2d7ccfcba2cfdf06e0f46eda55740

adcb3f45331ae020851b92757f2a7567f4c6978d9855cce197ef31b3c037602e

cadda460ccb4c3c01bb45f3d5976f63f5adf8dc3ff1d31cb4fbd3ded4f18e5bf

aeae3704a1ecd565e486e58ca8217de97c59a45f8a90b8902019b3f7247ba2ae

1df7118bd4d93e6e22ee0c9a753b2a6c1a4659e09858e0e5aec76baaffd28e0a

879e9a7202b2cc252ff4d9a6032d585ab66abb8925b7bbda6f7f0844ec990200

5d8d37321231b060b629363d13fb192c339dad46fac032c6b7fb25865d3c054d

c96f456d71003b23e247f270fb3243db23d5e64b374b73626e88331bf28e3edf

05397246f7c3afe9b189f60e2ccda8523aee2624ff2ef74d45ecd34f6f68f47c

1e3696feaafa6d2c9da46201ca8964356328736275e6a2703e3bb9eb35491c5e

33609fd87a1978ce3aea3f51de426a1f59321e076ffc248a9d7ae64380145dbd

0e7e3045519beaff2095d4a64b8dfb1b581013eb5b8f4b3549983c69abe7139b

ce24fe54ce3a08c6fffddbbd0efeda3cf530ea519bef2226d98139a1cb7d10d8

ac8fa90c300728059c7c6d6a8d2fd675ba449db521d4f3ed5c5af73bcff6398d

4b0a7c4f6ed387cc74de43eb92cda19209f19fcc28f2e441ad1a049d91d6b2e7

20bbb4334b041af31edc1c070ccef111df41c091efb9160e3604f5b541a597d1

c7305ef74c5fe93ec0827340ef5038696726d39fda35410516670ac8c64f1581

f1a61277e3f902f50ab42015d8b07218db9b7601bb0967e54a52bfdcb4fa7e81

script-src 'none'; form-action 'none'; frame-src 'none'; report-uri https://csp.withgoogle.com/csp/scaffolding/ascnsrsgac:225:0

b4eca20792a8139ff452377dfbe0d279d549c4d5457a360243976328f586563a

9b0e6c87b8134d106a055fed17c20256d93e8142fbab27f060f71992fa7fe3a2

058ed961bfe422af7bfc65865f4c08531ec8ace995f8a1ec560a46581cb7712c

f4e8d694198c9e7b1dcfee6996eb2b4224249768d895cb0d80e3a403bb6b6d9e

e01aa33982b1cd540157871cb27c77ef02449726f901e96baf7f156803e253df

6d8429b250b84f254438aafc59cc4abe2f54bcd4340b5363c8073b091417b46a

69724a256d017b34a356ff894a1c4a664f813960c71aa718046f1fc38ebd33cb

f618440c5a65218ef1e9a18457a86c358a5bffe250f87b34a2f7b949cc67a39b

0712cc0f410e61d90271dffcd586e0a67ec4ae5ca512e7371267183987fd85ac

4ae2b68898f9c8afd11c985e267f3db997c2b74a65c7fa55225a20d82b9dd135

78d7979bb811882fc070144fe2f54e6011a49ffdc45af778c1c3f98f45589fc5

e6f8062c71817788540c953736891c125b5717729b3671bcb37214d3436cb75b

c707d73f6347e1ff25a7c8182e2a636288b7edfc70ab72f0f6116895a8fea3dd

d0c6683f9261918705dcdc79854320e1fe8dcc8b9ee7880afecc460128b7876c

511bf11f92ae8d0925b31e0a8e1242d1308327a3df137e023b80528c5f065c46

b29f47bf2db2b5d398b67b997d6f06742d8eec098496762bd28041d02f16a8be

16f0b851ec84f74a85afdbcb91926d9842e5c4e22da520ad16a1b8b4e700f52d

0f459d5bdb89fe940d69367520a85817875fd5638d3a73fd441b3c5b09802941

801cdf2fc763f136bbd18945d9b1ac7a406a1067311e4269914c04837f47c1b8

ca05bd2f43ef8eae734737e3edaebe2a835a70034624e8d64e1243ee1ddc418c

31b81d3c65101906bb0703a6e5ab2d80f63d8b8ca302d8624a5cb8e3ad2afe81

512587dfd58c7a9cb19e7510e684f6f6a7d73124cbeee9fe40f2d771ff65b4b4

2c512fed28bbf29e99d3db3595e5038848e8569ec952e40434a90d939c3e7e12

99eda4911c3f01a7dcff202c558f366dc537220837829c2735791f878bd52e54

284ddfe386d47eaed56896f40986f241e8d9821397928d5005ef5b150c2d6760

e762d37b7444075a1cc698c2d91c04665904008cbbdda29639439fc807e7ddcc

54292 пункта выдачи по всей России

Компьютерная техника и ПО

viewport

➤ В интернет магазине КотоФото - широкий выбор актуальных товаров по отличным ценам. Гарантия производителя на все товары ★ Оперативная доставка в Санкт-Петербург ★ Регулярные выгодные акции и подарки нашим покупателям, возможна покупка в кредит

description

КотоФото - интернет магазин смартфонов, фототехники, электроники, цифровой и бытовой техники в Санкт-Петербурге

robots

msapplication-TileColor

theme-color

mailru-verification

require-trusted-types-for 'script'; report-uri https://csp.withgoogle.com/csp/recaptcha-scs

html/09/9c/099cf116-c3a7-492b-9db9-c9a499be16ff_nodriver.html.gz

kotofoto.ru

Abuse

Google LLC

GOOGLE


['click', 'scroll', 'mousemove', 'touchstart'].forEach(function(e) {
    window.addEventListener(e, ()=>{
        (function(w,d,s,l,i){
            w[l]=w[l]||[];w[l].push({'gtm.start': new Date().getTime(),event:'gtm.js'});
            var f=d.getElementsByTagName(s)[0],
            j=d.createElement(s),
            dl=l!='dataLayer'?'&l='+l:'';
            j.async=true;
            j.src='https://www.googletagmanager.com/gtm.js?id='+i+dl;
            f.parentNode.insertBefore(j,f);
        })(window,document,'script','dataLayer','GTM-MSSH3F6');
    }, {
        once: true
    });
});


 mindbox = window.mindbox || function() { mindbox.queue.push(arguments); };mindbox.queue = mindbox.queue || []; mindbox('create', { firebaseMessagingSenderId: '222568717451', serviceWorkerPath: '/mindbox-services-worker.js',serviceWorkerScope: '/'}); mindbox('webpush.create');

КотоФото

КотоФото Санкт-Петербург

(function () {

window.MindboxScripts = window.MindboxScripts || {};window.MindboxEndpointSettings = {"viewProductOperationSystemName":"ProductView","viewCategoryOperationSystemName":"CategoryView","s


    // Оптимизированная версия снегопада
    (function() {
        'use strict';
        
        // Элементы DOM
        const canvas = document.getElementById('snow-canvas');
        const ctx = canvas.getContext('2d');
        
        // Состояние анимации
        let isPaused = false;
        let lastTime = 0;
        let frameCount = 0;
        let lastFpsUpdate = 0;
        let currentFps = 60;
        let drawTime = 0;
        
        // Текущие логические размеры (CSS пиксели)
        let displayWidth = 0;
        let displayHeight = 0;
        let dpr = 1;
        
        // Конфигурация
        let config = {
            count: 150,
            speed: 3,
            minSize: 2,
            maxSize: 3,
            wind: 1,
            sway: 0,
            shadows: false,
            performanceMode: true,
            shadowColor: 'rgba(0,0,0,1)',
            fillStyle: '134,215,231',
        };
        
        // Данные снежинок
        let snowflakes = null;
        
        // Инициализация canvas
        function initCanvas() {
            resizeCanvas();
            window.addEventListener('resize', resizeCanvas);
        }
        
        // Изменение размера canvas при изменении размера окна
        function resizeCanvas() {
            dpr = window.devicePixelRatio || 1;
            const rect = canvas.getBoundingClientRect();
            
            // Сохраняем логические размеры (CSS пиксели)
            displayWidth = rect.width;
            displayHeight = rect.height;
            
            // Устанавливаем физический размер canvas (с учетом DPI)
            const physicalWidth = Math.floor(displayWidth * dpr);
            const physicalHeight = Math.floor(displayHeight * dpr);
            
            // Проверяем, изменился ли размер
            if (canvas.width !== physicalWidth || canvas.height !== physicalHeight) {
                canvas.width = physicalWidth;
                canvas.height = physicalHeight;
                
                // Корректируем стиль для четкого отображения
                canvas.style.width = displayWidth + 'px';
                canvas.style.height = displayHeight + 'px';
                
                // Сбрасываем трансформацию
                ctx.setTransform(1, 0, 0, 1, 0, 0);
                ctx.scale(dpr, dpr);
                
                // Корректируем позиции снежинок, если они вышли за границы
                if (snowflakes) {
                    for (let i = 0; i < config.count; i++) {
                        const baseIndex = i * 7;
                        // Корректируем X позицию
                        if (snowflakes[baseIndex] > displayWidth) {
                            snowflakes[baseIndex] = Math.random() * displayWidth;
                        }
                        // Корректируем Y позицию
                        if (snowflakes[baseIndex + 1] > displayHeight) {
                            snowflakes[baseIndex + 1] = Math.random() * displayHeight;
                        }
                    }
                }
            }
        }
        
        // Инициализация снежинок
        function initSnowflakes() {
            // Создаем типизированные массивы для хранения данных снежинок
            const dataSize = config.count * 7;
            snowflakes = new Float32Array(dataSize);
            
            // Инициализируем снежинки
            for (let i = 0; i < config.count; i++) {
                initSnowflake(i);
            }
        }
        
        // Инициализация отдельной снежинки
        function initSnowflake(index) {
            const baseIndex = index * 7;
            
            // Позиция X (случайная по ширине экрана)
            snowflakes[baseIndex] = Math.random() * displayWidth;
            
            // Позиция Y (случайная по высоте экрана)
            snowflakes[baseIndex + 1] = Math.random() * displayHeight;
            
            // Размер (от minSize до maxSize)
            const sizeRange = config.maxSize - config.minSize;
            snowflakes[baseIndex + 2] = Math.random() * sizeRange + config.minSize;
            
            // Скорость падения (зависит от размера - большие падают быстрее)
            const size = snowflakes[baseIndex + 2];
            snowflakes[baseIndex + 3] = (size / 5) * config.speed * 0.5 + config.speed * 0.1;
            
            // Ветер (случайное отклонение)
            snowflakes[baseIndex + 4] = (Math.random() - 0.5) * config.wind * 0.5;
            
            // Фаза колебаний (для уникального движения каждой снежинки)
            snowflakes[baseIndex + 5] = Math.random() * Math.PI * 2;
            
            // Скорость колебаний
            snowflakes[baseIndex + 6] = Math.random() * 0.05 + 0.01;
        }
        
        // Обновление всех снежинок
        function updateSnowflakes(deltaTime) {
            if (isPaused) return;
            
            // Нормализуем deltaTime для плавности анимации
            const timeFactor = Math.min(deltaTime / 16, 2);
            
            // Получаем текущие параметры из конфига
            const swayAmount = config.sway * 0.1;
            
            // Обновляем все снежинки в одном цикле для производительности
            for (let i = 0; i < config.count; i++) {
                const baseIndex = i * 7;
                
                // Обновляем фазу колебаний
                snowflakes[baseIndex + 5] += snowflakes[baseIndex + 6] * timeFactor;
                
                // Вычисляем горизонтальное смещение от ветра и колебаний
                const wind = snowflakes[baseIndex + 4];
                const sway = Math.sin(snowflakes[baseIndex + 5]) * swayAmount;
                const horizontalMovement = (wind + sway) * timeFactor;
                
                // Обновляем позицию
                snowflakes[baseIndex] += horizontalMovement; // X
                snowflakes[baseIndex + 1] += snowflakes[baseIndex + 3] * timeFactor; // Y
                
                // Если снежинка ушла за нижнюю границу, переставляем ее вверху
                if (snowflakes[baseIndex + 1] > displayHeight) {
                    snowflakes[baseIndex + 1] = -10; // Начинаем сверху
                    snowflakes[baseIndex] = Math.random() * displayWidth; // Случайная позиция X
                    
                    // Обновляем размер при респавне
                    const sizeRange = config.maxSize - config.minSize;
                    snowflakes[baseIndex + 2] = Math.random() * sizeRange + config.minSize;
                    
                    // Обновляем скорость в зависимости от нового размера
                    const size = snowflakes[baseIndex + 2];
                    snowflakes[baseIndex + 3] = (size / 5) * config.speed * 0.5 + config.speed * 0.1;
                }
                
                // Если снежинка ушла за горизонтальные границы, переносим на другую сторону
                if (snowflakes[baseIndex] > displayWidth) {
                    snowflakes[baseIndex] = 0;
                } else if (snowflakes[baseIndex] < 0) {
                    snowflakes[baseIndex] = displayWidth;
                }
            }
        }
        
        // Отрисовка всех снежинок
        function drawSnowflakes() {
            const startTime = performance.now();
            
            // Полностью очищаем canvas в физических координатах
            ctx.save();
            ctx.setTransform(1, 0, 0, 1, 0, 0);
            ctx.clearRect(0, 0, canvas.width, canvas.height);
            ctx.restore();
            
            // Устанавливаем правильную трансформацию для рисования
            ctx.setTransform(dpr, 0, 0, dpr, 0, 0);
            
            // Отключаем сглаживание для четких краев
            ctx.imageSmoothingEnabled = false;
            
            // Рисуем все снежинки в одном цикле
            for (let i = 0; i < config.count; i++) {
                const baseIndex = i * 7;
                const x = snowflakes[baseIndex];
                const y = snowflakes[baseIndex + 1];
                const size = snowflakes[baseIndex + 2];
                
                // Пропускаем снежинки, которые не видны (вышли за границы)
                if (y < -size || y > displayHeight + size || 
                    x < -size || x > displayWidth + size) {
                    continue;
                }
                
                // Настраиваем прозрачность (меньшие снежинки более прозрачные)
                const opacity = config.performanceMode ? 0.8 : 0.5 + (size / config.maxSize) * 0.5;
                
                // Рисуем снежинку
                ctx.beginPath();
                
                if (config.shadows) {
                    // Добавляем тень для реалистичности
                    ctx.shadowColor = config.shadowColor;
                    ctx.shadowBlur = size * 1.5;
                } else {
                    ctx.shadowBlur = 0;
                }
                
                // Заливка снежинки
                ctx.fillStyle = `rgba(${config.fillStyle}, ${opacity})`;
                
                // Используем целые координаты для предотвращения артефактов
                const drawX = Math.round(x);
                const drawY = Math.round(y);
                const drawSize = Math.max(1, Math.round(size));
                
                ctx.arc(drawX, drawY, drawSize, 0, Math.PI * 2);
                ctx.fill();
                
                // Закрываем путь после каждой снежинки
                ctx.closePath();
            }
            
            // Сбрасываем тень
            ctx.shadowBlur = 0;
            ctx.shadowColor = 'transparent';
            
            // Сбрасываем трансформацию
            ctx.setTransform(1, 0, 0, 1, 0, 0);
            
            drawTime = performance.now() - startTime;
        }
        
        // Основной цикл анимации
        function animate(currentTime) {
            frameCount++;
            
            // Вычисляем deltaTime для плавной анимации
            const deltaTime = lastTime ? currentTime - lastTime : 16;
            lastTime = currentTime;
            
            // Обновляем FPS каждую секунду
            if (currentTime - lastFpsUpdate >= 1000) {
                currentFps = Math.round((frameCount * 1000) / (currentTime - lastFpsUpdate));
                lastFpsUpdate = currentTime;
                frameCount = 0;
            }
            
            // Обновляем и рисуем снежинки
            updateSnowflakes(deltaTime);
            drawSnowflakes();
            
            // Запрашиваем следующий кадр
            if (!isPaused) {
                requestAnimationFrame(animate);
            }
        }
        
        // Проверка и корректировка размера
        function validateSizeRange() {
            // Убедимся, что минимальный размер меньше максимального
            if (config.minSize >= config.maxSize) {
                config.maxSize = config.minSize + 1;
                if (config.maxSize > 20) {
                    config.maxSize = 20;
                    config.minSize = 19;
                }
            }
            
            // Обновляем все снежинки при изменении размера
            if (snowflakes) {
                for (let i = 0; i < config.count; i++) {
                    const baseIndex = i * 7;
                    const currentSize = snowflakes[baseIndex + 2];
                    const sizeRange = config.maxSize - config.minSize;
                    
                    // Если текущий размер выходит за новые границы, пересчитываем
                    if (currentSize < config.minSize || currentSize > config.maxSize) {
                        snowflakes[baseIndex + 2] = Math.random() * sizeRange + config.minSize;
                        
                        // Обновляем скорость в зависимости от нового размера
                        const size = snowflakes[baseIndex + 2];
                        snowflakes[baseIndex + 3] = (size / 5) * config.speed * 0.5 + config.speed * 0.1;
                    }
                }
            }
        }
        
        // Инициализация приложения
        function init() {
            initCanvas();
            initSnowflakes();
            requestAnimationFrame(animate);
        }
        
        // Запускаем приложение после загрузки страницы
        window.addEventListener('load', init);
        
        // Оптимизация для фоновых вкладок
        document.addEventListener('visibilitychange', function() {
            if (document.hidden) {
                // Пауза анимации при скрытии вкладки
                isPaused = true;
                lastTime = 0;
                
                // Восстанавливаем при возвращении на вкладку
                document.addEventListener('visibilitychange', function restore() {
                    if (!document.hidden) {
                        isPaused = false;
                        lastTime = 0;
                        requestAnimationFrame(animate);
                        document.removeEventListener('visibilitychange', restore);
                    }
                }, { once: true });
            }
        });
        
        // Дополнительная оптимизация для медленных устройств
        let slowDevice = false;
        const detectSlowDevice = () => {
            if (currentFps < 30 && !slowDevice) {
                slowDevice = true;
                // Уменьшаем количество снежинок на медленных устройствах
                const originalCount = config.count;
                config.count = Math.min(100, Math.floor(config.count * 0.7));
                if (snowflakes) {
                    initSnowflakes();
                }
                console.log('Slow device detected, reducing snowflake count');
            }
        };
        
        // Проверка производительности каждые 5 секунд
        setInterval(detectSlowDevice, 5000);
        
    })();



        dataLayer.push({'event': 'promotionView','ecommerce': {'promoView': {'promotions': [[
    {
        "id": "index_smoll_1_banner_32",
        "name": "1000 рублей  гарантия исполнения заказа!",
        "creative": "https:\/\/kotofoto.ru\/promotion\/id_299_1000_rubley_garantiya_ispolneniya_zakaza.html",
        "position": "top"
    }
]]}}});
        
    


        dataLayer.push({'event': 'promotionView','ecommerce': {'promoView': {'promotions': [[
    {
        "id": "index_smoll_2_banner_496",
        "name": "Телеграм-канал Котофото",
        "creative": "https:\/\/t.me\/kotofoto",
        "position": "top"
    }
]]}}});
        
    

(function(a){var b=a.createElement("script");b.async=1;b.src="//icyh3e.ru/";a=a.getElementsByTagName("script")[0];a.parentNode.insertBefore(b,a)})(document);

var digiScript=document.createElement("script");digiScript.src="//cdn.diginetica.net/271/client.js";digiScript.defer=!0;digiScript.async=!0;document.head.appendChild(digiScript);

window.dataLayer=window.dataLayer||[];function gtag(){dataLayer.push(arguments)}gtag("js",new Date);gtag("config","G-3KKBXY6RM3");

window.advcake_data=window.advcake_data||[];window.advcake_data.push({pageType:1,user:{email:""}});

Requests	IP Address	Location	AS Autonomous System
15	85.119.149.154	Moscow, Moscow, Russia	AS50340JSC Selectel
14	90.156.232.15	Russia	AS47764LLC VK
14	95.163.52.67	Russia	AS47764LLC VK
14	142.250.184.227	Russia	AS47764
14	142.251.141.100	Russia	AS200350
14	95.181.182.182	Perm, Perm Krai, Russia	AS210756EdgeCenter LLC
14	142.250.186.155	Russia	Unknown
14	172.217.18.27	United States	AS15169GOOGLE
14	142.250.186.170	United States	AS15169GOOGLE
14	84.252.133.97	Russia	AS200350Yandex.Cloud LLC
155	11	-	-

Security Scan Report: kotofoto.ru

Summary

AI Security Verdict

Safe Website

Safety Factors

Details

Screenshot

Page Load Overview

Language Analysis

Primary Language

Detection Details

Website Classification

Primary Category

All Detected Categories

Detected Features

Domain & IP Information

Detected Technologies2

Content Similarity HashesFor malware variant detection

TLSH (Trend Micro Locality Sensitive Hash)

ssdeep (Context Triggered Piecewise Hashing)

sdhash (Similarity Digest Hashing)

Image Hashes

Perceptual Hashes

Other Hashes

Scan History