Import passwords from Kaspersky

Please we need a work around for this issue Norton 360 Team - 

Hi everyone,

I wrote a PowerShell script which is capable of converting Kaspersky Passwords of type "website" and "applications" into a CSV file which can be imported into the Google Password Manager. My plan was to go from "Kaspersky > Google > Norton" as there is no native way to import Kaspersky passwords into Norton and I couldn't get the Norton CSV Importer to work.

Unfortunately I also can't get the native Norton Chrome & Firefox Password importer app to work on my PC for unknown reasons. The json file to be uploaded to Norton for importing Google passwords does not get created when I run the exe file. There also seems to be no solution to this online, which means that we are waiting on Norton development. I have now given up on pursuing this case and have cancelled my Norton 360 subscription, I am sticking with Kaspersky even in the current political situation. 

Having tested Norton 360 for a month, I think the Anti-Virus solution is well implemented, especially with perks like dark web monitoring and spam filtering etc. However I do not like the Norton Password Manager and the fact that it doesn't have a full client like Kaspersky does. One is able to do a lot more with Kaspersky Passsword Manager like upload important files, store application passwords which is not given in Norton. Furthermore, this may come off as a joke for you, but I hate that the Norton Password Manager iOS app does not have Dark mode. Granted this isn't a deal breaker, it's Q2 2022, everyone has dark mode by now and who ever doesn't is just plain sloppy in my opinion.

Here's the script, copy the contents below or download the text file attached and paste contents to "PowerShell ISE" on your computer. Read the Warning and instructions below, configure the variables inside the "User Input Need" block and run the script by pressing F5. As mentioned, the result file can be successfully imported to Google Password Manager but I couldn't get any further than that.

I wish you better luck in your journey on switching over to Norton from Kaspersky.

<#
======================
=====!!WARNINGS!!=====
======================

1) This script will not work if you use double quotation marks (") in your passwords
   Change quotation marks to another character before continuing
   I have not tested if Google password manager can process single quotations (') so change them too 

2) Applications passwords in Kaspersky will receive a dummy URL
   In Kaspersky Application passwords have no URLs and Google Password Manager does not support empty URLs
   To workaround this, the application name will be used as the application URL
   For example if you have an App called "Twitch TV App" then the password for that Entry will be "https://www.TwitchTVApp.AppPass"
   If you don't want to process application passwords, set "$processApplications = $false" below
   Otherwise you can set a prefix for application names and a domain name to be used for easier searching in Norton
   The final App dummyName format is https://www.<dummyAppPrefix><AppName><dummyDomainName>

3) Notes will not be processed
   Google Password Manager does not support Notes  
   It is  unclear how to import notes into Norton per CSV

4) URLs will formated
   Google Password Manager does not accept URLs which do not start with "https://www." or "http://www."
   This script will convert URLs from "https://" or "http://" to the format mentioned above
   Furthermore URLs such as "twitch.tV" or "www.twitch.tv" is also not accepted by Google 
   In this case the script will add "https://www." to URLs like "twitch.tV"
   Since the script cannot check if a URL is meant to be "http://" or "https://"
   Please check results file with tag "Assumption made for" and correct connection type where necessary
#>

<#=======================#>
<#===USER INPUT NEEDED===#>
<#=======================#>

#Enter the full path to your Kaspersky password export file below
$importFilePath = 'C:\Users\YourUserName\Desktop\test.txt'

#Enter the full path to export your converted file to import to chrome
$exportFilePath = 'C:\Users\YourUserName\Desktop\importToChrome.csv'

#Any alterations to URLs will be listed in this file, which will be dumped in the same directory as above. Set file name
$resultsFileName = '\conversionResults.txt'

#Choose if application passwords shall be processed (read warning #2 above. True by default)
$processApplications = $true
#$processApplications = $false

#Choose prefix name for dummy URLs for application passwords
#Set value to empty '' if you do not wish to add a prefix
$dummyAppPrefix = ''

#Choose domain name for dummy URLs for application passwords
$dummyDomainName = '.AppPass'
<#=======================#>
<#=== END USER INPUT ====#>
<#=======================#>

<#===Helper Functions===#>
function Test-ImportFilePath {
  param(
      [Parameter(Mandatory=$true)][string]$importFilePath
  )

  #retrieve file content and remove empty lines
  try {
      $fileExists = Test-Path -Path $importFilePath
      if (-not $fileExists) {
        Throw [string]::Format('Error the specified file path "{0}" does not exist', $importFilePath)
      }
  } catch {
      Write-Error -Message 'An unkonwn error occured'
      Throw $_
  }
}
function Set-ExportFilePath {
    param (
        [Parameter(Mandatory=$true)][string]$filePath, 
        [Parameter(Mandatory=$true)][string]$fileName 
    )

    if (-not $fileName.StartsWith('\')) {
        $fileName  = '\' + $fileName 
    }
    if ([string]::IsNullOrEmpty([IO.Path]::GetExtension($fileName))) {
        $fileName = $fileName  + '.txt'
    }

    return [IO.Path]::GetDirectoryName($filePath) + $fileName
}

function Format-DummyDomainName {
  param (
        [Parameter(Mandatory=$true)][string]$domainName
    )

  if (-Not $domainName.StartsWith('.')) {
    $domainName = '.' + $domainName
  }
  return $domainName
}

function Format-URL {
    param(
        [Parameter(Mandatory=$true)][string]$url
    )

    #define URL formatting patterns
    $msgPrefix = 'Changed URL'
    $isURLConversion = $true
    $isAssumption = $false
    $patternURLIsOk = '(?i)^(https://|http://)(www.)'
    $patternHypertextOnly = '(?i)^(https://|http://)'
    $patternHttps = '(?i)^(https://)'
    $patternHttpsCorrect = 'https://www.'
    $patternHttp = '(?i)^(http://)'
    $patternHttpCorrect = 'http://www.'
    $patternLeadingWs = '(?i)^(www.)'

    switch -Regex ($url) {
        $patternURLIsOk {
            $retUrl = $url
            $isURLConversion = $false
            break
        }
        $patternHypertextOnly {
            switch -Regex ($url) {
                $patternHttps {
                    $retUrl = $url -replace ($patternHttps, $patternHttpsCorrect)
                    break
                }
                $patternHttp {
                    $retUrl = $url -replace ($patternHttp, $patternHttpCorrect)
                    break
                }
            }
        }
        $patternLeadingWs {
            #URL has "www." as prefix set to "https://www."
            $isAssumption = $true
            $retUrl = $url -replace ($patternLeadingWs, $urlPrefix)
            break
        }
        default {
            #format URL
            $isAssumption = $true
            $retUrl = $urlPrefix + $url
        }
    }
    if ($isURLConversion) {
        if ($isAssumption) {
            $msgPrefix = 'Assumption made for'
        }
        $msg = [string]::Format('{0} "{1}" to "{2}"', $msgPrefix ,$url, $retUrl)
        $null = $resultStringBuilder.AppendLine($msg)
    }
    return $retUrl
}

<#======================#>
<#== Start Conversion ==#>
<#======================#>

#Check import file path
Test-ImportFilePath -importFilePath $importFilePath

#Set results file path
$resultsFilePath = Set-ExportFilePath -filePath $exportFilePath -fileName $resultsFileName

#Declare and set variables
#mapping to google password manager
$name = ''
$url = ''
$username = ''
$password = ''

#helper variables
$counter = 0
$stopProcessing = $false
$isApplication = $false
$urlPrefix = 'https://www.'

#define regex patterns to recognise line feed imported from Kaspersky
$patternName = '^(Website name: |Application: )'
$patternURL = '^(Website URL: )'
$patternUserName = '^(Login: )'
#$patternUserName = '^(Login name: )'
$patternPassWord = '^(Password: )'
$patternLinesToIgnore = '^(Websites|---|Comment: |Login name: )'
$patternApplications= '^(Applications)' 
$patternStopProcessing = '^(Notes)'

#prepare export files
$exportStringBuilder = New-Object -TypeName System.Text.StringBuilder
$resultStringBuilder = New-Object -TypeName System.Text.StringBuilder
$null = $exportStringBuilder.AppendLine('"name","url","username","password"')

#import the kaspersky file
$file = Get-Content -Path $importFilePath | Where-Object{$_ -ne ''}

try {
    foreach($line in $file) {

        $skipLine = $false

        if ($stopProcessing) {
            break
        } elseif ($line -match $patternLinesToIgnore) {
            #skip lines to ignore
            continue
        }

        #process lines of interest
        switch -Regex ($line) {
            $patternName {
                $name = $line -replace ($patternName,'')
                break
            }
            $patternURL {
                $url = Format-URL -url ($line -replace ($patternURL,''))
                break
            }
            $patternUserName {
                $username = $line -replace ($patternUserName,'')
                break
            }
            $patternPassWord {
                $password = $line -replace ($patternPassWord,'')
                break
            }
            $patternApplications{
                #reached Applications section, check further processing
                if ($processApplications) {
                    $isApplication = $true
                    $dummyDomainName = Format-DummyDomainName -domainName $dummyDomainName
                    continue
                } else {
                    $stopProcessing = $true
                }
            }
            $patternStopProcessing {
                #reached Notes section, stop here
                $stopProcessing = $true
            }
            default {
                #Comment section may have mutiple lines, skip line
                $skipLine = $true
            }
        }

        #check processing occured
        if (-Not $skipLine) {
          $counter++
        }

        #process each 4th block
        if ($counter -eq 4) {
            if ($isApplication) {
                $url = [string]::Format('{0}{1}{2}{3}', $urlPrefix, $dummyAppPrefix, ($name -replace '\s',''), $dummyDomainName)
                $msg = [string]::Format('Application "{0}" uses URL "{1}"', $name, $url)
                $null = $resultStringBuilder.AppendLine($msg)
            }

            $exportLine = [string]::Format('"{0}","{1}","{2}","{3}"',$name,$url,$username,$password)
            $null = $exportStringBuilder.AppendLine($exportLine)

            #reset variables
            $name = ''
            $url = ''
            $username = ''
            $password = ''
            $counter = 0
            
        }
    }
} catch {
    Throw $_
}

#export file
[IO.File]::WriteAllText($exportFilePath,$exportStringBuilder.ToString())
[IO.File]::WriteAllText($resultsFilePath,$resultStringBuilder.ToString())