@contrast/contrast 1.0.0 → 1.0.1

package/src/constants.js

@@ -27,7 +27,7 @@ const scanOptionDefinitions = [
       '{bold ' +
       i18n.__('constantsOptional') +
       '}: ' +
-      i18n.__('constantsFileName')
+      i18n.__('scanOptionsFileNameSummary')
   },
   {
     name: 'project-id',
@@ -46,16 +46,7 @@ const scanOptionDefinitions = [
       '{bold ' +
       i18n.__('constantsOptional') +
       '}: ' +
-      i18n.__('constantsScanTimeout')
-  },
-  {
-    name: 'language',
-    alias: 'l',
-    description:
-      '{bold ' +
-      i18n.__('constantsRequiredCatalogue') +
-      '}: ' +
-      i18n.__('constantsLanguage')
+      i18n.__('scanOptionsTimeoutSummary')
   },
   {
     name: 'organization-id',
@@ -66,15 +57,6 @@ const scanOptionDefinitions = [
       '}: ' +
       i18n.__('constantsOrganizationId')
   },
-  {
-    name: 'yaml-path',
-    alias: 'y',
-    description:
-      '{bold ' +
-      i18n.__('constantsOptional') +
-      '}: ' +
-      i18n.__('constantsYamlPath')
-  },
   {
     name: 'api-key',
     description:
@@ -94,7 +76,6 @@ const scanOptionDefinitions = [
   {
     name: 'host',
     alias: 'h',
-    defaultValue: 'app.contrastsecurity.com',
     description:
       '{bold ' +
       i18n.__('constantsRequired') +
@@ -127,9 +108,173 @@ const scanOptionDefinitions = [
       '}:' +
       i18n.__('constantsIgnoreCertErrors')
   },
+  {
+    name: 'verbose',
+    alias: 'v',
+    type: Boolean,
+    description:
+      '{bold ' +
+      i18n.__('constantsOptional') +
+      '}:' +
+      i18n.__('scanOptionsVerboseSummary')
+  },
+  {
+    name: 'save',
+    alias: 's',
+    description:
+      '{bold ' + i18n.__('constantsOptional') + '}:' + i18n.__('constantsSave')
+  },
   {
     name: 'help',
     type: Boolean
+  },
+  {
+    name: 'debug',
+    alias: 'd',
+    type: Boolean
+  }
+]
+
+const auditOptionDefinitions = [
+  {
+    name: 'application-id',
+    description:
+      '{bold ' +
+      i18n.__('constantsRequired') +
+      '}: ' +
+      i18n.__('constantsApplicationId')
+  },
+  {
+    name: 'application-name',
+    description:
+      '{bold ' +
+      i18n.__('constantsOptional') +
+      '}: ' +
+      i18n.__('constantsApplicationName')
+  },
+  {
+    name: 'project-path',
+    defaultValue: process.env.PWD,
+    description:
+      '{bold ' +
+      i18n.__('constantsOptional') +
+      '}: ' +
+      i18n.__('constantsProjectPath')
+  },
+  {
+    name: 'app-groups',
+    description:
+      '{bold ' +
+      i18n.__('constantsOptionalForCatalogue') +
+      '}: ' +
+      i18n.__('constantsAppGroups')
+  },
+  {
+    name: 'sub-project',
+    description:
+      '{bold ' +
+      i18n.__('constantsOptional') +
+      '}: ' +
+      i18n.__('constantsGradleMultiProject')
+  },
+  {
+    name: 'metadata',
+    description:
+      '{bold ' +
+      i18n.__('constantsOptional') +
+      '}: ' +
+      i18n.__('constantsMetadata')
+  },
+  {
+    name: 'tags',
+    description:
+      '{bold ' + i18n.__('constantsOptional') + '}: ' + i18n.__('constantsTags')
+  },
+  {
+    name: 'code',
+    description:
+      '{bold ' + i18n.__('constantsOptional') + '}: ' + i18n.__('constantsCode')
+  },
+  {
+    name: 'ignore-dev',
+    type: Boolean,
+    description:
+      '{bold ' +
+      i18n.__('constantsOptional') +
+      '}: ' +
+      i18n.__('constantsIgnoreDev')
+  },
+  {
+    name: 'maven-settings-path'
+  },
+  {
+    name: 'language',
+    alias: 'l',
+    description:
+      '{bold ' +
+      i18n.__('constantsRequiredCatalogue') +
+      '}: ' +
+      i18n.__('constantsLanguage')
+  },
+  {
+    name: 'organization-id',
+    alias: 'o',
+    description:
+      '{bold ' +
+      i18n.__('constantsRequired') +
+      '}: ' +
+      i18n.__('constantsOrganizationId')
+  },
+  {
+    name: 'api-key',
+    description:
+      '{bold ' +
+      i18n.__('constantsRequired') +
+      '}: ' +
+      i18n.__('constantsApiKey')
+  },
+  {
+    name: 'authorization',
+    description:
+      '{bold ' +
+      i18n.__('constantsRequired') +
+      '}: ' +
+      i18n.__('constantsAuthorization')
+  },
+  {
+    name: 'host',
+    alias: 'h',
+    description:
+      '{bold ' +
+      i18n.__('constantsRequired') +
+      '}: ' +
+      i18n.__('constantsHostId')
+  },
+  {
+    name: 'proxy',
+    description:
+      '{bold ' +
+      i18n.__('constantsOptional') +
+      '}: ' +
+      i18n.__('constantsProxyServer')
+  },
+  {
+    name: 'ignore-cert-errors',
+    type: Boolean,
+    description:
+      '{bold ' +
+      i18n.__('constantsOptional') +
+      '}:' +
+      i18n.__('constantsIgnoreCertErrors')
+  },
+  {
+    name: 'save',
+    alias: 's',
+    description:
+      '{bold ' +
+      i18n.__('constantsOptional') +
+      '}: ' +
+      i18n.__('auditOptionsSaveDescription')
   }
 ]
 
@@ -163,6 +308,7 @@ module.exports = {
   commandLineDefinitions: {
     mainUsageGuide,
     mainDefinition,
-    scanOptionDefinitions
+    scanOptionDefinitions,
+    auditOptionDefinitions
   }
 }

package/src/index.ts

@@ -1,4 +1,5 @@
 import commandLineArgs from 'command-line-args'
+import { processAudit } from './commands/audit/processAudit'
 import { processAuth } from './commands/auth/auth'
 import { processConfig } from './commands/config/config'
 import { processScan } from './commands/scan/processScan'
@@ -6,6 +7,7 @@ import constants from './constants'
 import { APP_NAME, APP_VERSION } from './constants/constants'
 import { processLambda } from './lambda/lambda'
 import { localConfig } from './utils/getConfig'
+import findLatestCLIVersion from './common/findLatestCLIVersion'
 
 const {
   commandLineDefinitions: { mainUsageGuide, mainDefinition }
@@ -36,6 +38,8 @@ const start = async () => {
     return
   }
 
+  await findLatestCLIVersion()
+
   if (command === 'config') {
     return processConfig(argvMain, config)
   }
@@ -48,9 +52,12 @@ const start = async () => {
     return await processLambda(argvMain)
   }
 
-  /* second - parse the merge command options */
   if (command === 'scan') {
-    return await processScan()
+    return await processScan(argvMain)
+  }
+
+  if (command === 'audit') {
+    return await processAudit(argvMain)
   }
 
   if (

package/src/lambda/aws.ts

@@ -1,3 +1,4 @@
+import i18n from 'i18n'
 import {
   Lambda,
   GetFunctionCommand,
@@ -44,12 +45,9 @@ const getLambdaClient = (lambdaOptions: LambdaOptions) => {
     const clientOptions = getAwsClientOptions(lambdaOptions)
     return new Lambda(clientOptions)
   } catch (error) {
-    const errorObj = error as any
-    if (errorObj?.code === 'ERR_INVALID_URL') {
-      throw new CliError(ERRORS.AWS_ERROR, { description: errorObj.message })
-    }
-
-    throw error
+    throw new CliError(ERRORS.AWS_ERROR, {
+      description: (error as Error).message
+    })
   }
 }
 
@@ -89,7 +87,9 @@ const getLayersLinks = async (
       }
     } catch (e) {
       if (e instanceof ResourceNotFoundException) {
-        e.message = `The layer ${layerDict.Arn} could not be found. We will continue the scan without it.`
+        e.message = i18n.__('layerNotFound', {
+          layerArn: layerDict.Arn || 'unknown_arn'
+        })
         throw e
       }
       throw e
@@ -190,10 +190,10 @@ const getAttachedPolicies = async (roleName: string, client: IAMClient) => {
   )
   const attachedPoliciesPromises = listAttachedPolicies.map(
     async (policyDict: { PolicyArn: any; PolicyName: any }) => {
-      const getPolicyCommand = new GetPolicyCommand({
-        PolicyArn: policyDict.PolicyArn
-      })
+      const { PolicyArn, PolicyName } = policyDict
+      const getPolicyCommand = new GetPolicyCommand({ PolicyArn })
       const policy = await client.send(getPolicyCommand)
+
       if (policy.Policy) {
         const getPolicyVersionCommand = new GetPolicyVersionCommand({
           PolicyArn: policy.Policy.Arn,
@@ -203,8 +203,9 @@ const getAttachedPolicies = async (roleName: string, client: IAMClient) => {
         const policyDoc = JSON.parse(
           decodeURIComponent(policyVersion?.PolicyVersion?.Document || '{}')
         )
-        policyDoc['PolicyName'] = policyDict.PolicyName
-        policyDoc['PolicyArn'] = policyDict.PolicyArn
+
+        policyDoc['PolicyName'] = PolicyName
+        policyDoc['PolicyArn'] = PolicyArn
         return policyDoc
       }
     }

package/src/lambda/help.ts

@@ -21,6 +21,10 @@ const lambdaUsageGuide = commandLineUsage([
         name: i18n.__('lambdaFunctionNameOption'),
         summary: i18n.__('lambdaFunctionNameSummery')
       },
+      {
+        name: i18n.__('lambdaListFunctionsOption'),
+        summary: i18n.__('lambdaListFunctionsSummery')
+      },
       {
         name: i18n.__('lambdaEndpointOption'),
         summary:

package/src/lambda/lambda.ts

@@ -10,10 +10,12 @@ import { log } from './logUtils'
 import { pollScanUntilCompletion } from './scanDetailCompletion'
 import { requestScanFunctionPost } from './scanRequest'
 import { getScanResults } from './scanResults'
-import { prettyPrintResults } from './utils'
+import { printResults } from './utils'
+import { getAllLambdas, printAvailableLambdas } from './lambdaUtils'
 
 type LambdaOptions = {
   functionName?: string
+  listFunctions?: boolean
   region?: string
   endpointUrl?: string
   profile?: string
@@ -42,38 +44,49 @@ const printHelpMessage = () => {
 }
 
 const getLambdaOptions = (argv: string[]) => {
-  const lambdaDefinitions = [
-    { name: 'function-name', alias: 'f', type: String },
-    { name: 'region', alias: 'r', type: String },
-    { name: 'endpoint-url', alias: 'e', type: String },
-    { name: 'profile', alias: 'p', type: String },
-    { name: 'help', alias: 'h', type: Boolean },
-    { name: 'verbose', alias: 'v', type: Boolean },
-    { name: 'json-output', alias: 'j', type: Boolean }
-  ]
-
-  const lambdaOptions: LambdaOptions = commandLineArgs(lambdaDefinitions, {
-    argv,
-    partial: true,
-    camelCase: true,
-    caseInsensitive: true
-  })
-
-  return lambdaOptions
+  try {
+    const lambdaDefinitions = [
+      { name: 'function-name', alias: 'f', type: String },
+      { name: 'list-functions', alias: 'l', type: Boolean },
+      { name: 'region', alias: 'r', type: String },
+      { name: 'endpoint-url', alias: 'e', type: String },
+      { name: 'profile', alias: 'p', type: String },
+      { name: 'help', alias: 'h', type: Boolean },
+      { name: 'verbose', alias: 'v', type: Boolean },
+      { name: 'json-output', alias: 'j', type: Boolean }
+    ]
+
+    const lambdaOptions: LambdaOptions = commandLineArgs(lambdaDefinitions, {
+      argv,
+      partial: true,
+      camelCase: true,
+      caseInsensitive: true
+    })
+
+    return lambdaOptions
+  } catch (error) {
+    throw new CliError(ERRORS.VALIDATION_FAILED, {
+      description: (error as Error).message
+    })
+  }
 }
 
 const processLambda = async (argv: string[]) => {
-  const lambdaOptions = getLambdaOptions(argv)
-  const { help } = lambdaOptions
+  try {
+    const lambdaOptions = getLambdaOptions(argv)
+    const { help } = lambdaOptions
 
-  if (help) {
-    return handleLambdaHelp()
-  }
+    if (help) {
+      return handleLambdaHelp()
+    }
 
-  try {
     validateRequiredLambdaParams(lambdaOptions)
 
-    await actualProcessLambda(lambdaOptions)
+    if (lambdaOptions.listFunctions) {
+      await getAvailableFunctions(lambdaOptions)
+    } else {
+      await actualProcessLambda(lambdaOptions)
+    }
   } catch (error) {
     if (error instanceof CliError) {
       console.error(error.getErrorMessage())
@@ -84,6 +97,11 @@ const processLambda = async (argv: string[]) => {
   }
 }
 
+const getAvailableFunctions = async (lambdaOptions: LambdaOptions) => {
+  const lambdas = await getAllLambdas(lambdaOptions)
+  printAvailableLambdas(lambdas, { runtimes: ['python', 'java'] })
+}
+
 const actualProcessLambda = async (lambdaOptions: LambdaOptions) => {
   const auth = getAuth()
   const startTime = performance.now()
@@ -134,18 +152,20 @@ const actualProcessLambda = async (lambdaOptions: LambdaOptions) => {
   log(`----- Scan completed ${(scanDurationMs / 1000).toFixed(2)}s -----`)
 
   if (results?.length) {
-    prettyPrintResults(results)
+    printResults(results)
   }
 }
 
 const validateRequiredLambdaParams = (options: LambdaOptions) => {
   if (options._unknown?.length) {
     throw new CliError(ERRORS.VALIDATION_FAILED, {
-      description: i18n.__('notSupportedFlags', options._unknown.join('\n'))
+      description: i18n.__('notSupportedFlags', {
+        flags: options._unknown.join('\n')
+      })
     })
   }
 
-  if (!options?.functionName) {
+  if (!options?.functionName && !options?.listFunctions) {
     throw new CliError(ERRORS.VALIDATION_FAILED, {
       errorCode: 'missingFunctionName'
     })
@@ -158,10 +178,9 @@ const validateRequiredLambdaParams = (options: LambdaOptions) => {
 
   if (flagsWithoutValues.length) {
     throw new CliError(ERRORS.VALIDATION_FAILED, {
-      description: i18n.__(
-        'missingFlagArguments',
-        flagsWithoutValues.join('\n')
-      )
+      description: i18n.__('missingFlagArguments', {
+        flags: flagsWithoutValues.join('\n')
+      })
     })
   }
 }
@@ -171,4 +190,4 @@ const handleLambdaHelp = () => {
   process.exit(0)
 }
 
-export { processLambda, LambdaOptions, ApiParams }
+export { processLambda, LambdaOptions, ApiParams, getAvailableFunctions }

package/src/lambda/lambdaUtils.ts

@@ -0,0 +1,111 @@
+import logSymbols from 'log-symbols'
+import chalk from 'chalk'
+import i18n from 'i18n'
+import {
+  FunctionConfiguration,
+  ListFunctionsCommand
+} from '@aws-sdk/client-lambda'
+import { groupBy, sortBy } from 'lodash'
+import { getLambdaClient } from './aws'
+import ora from '../utils/oraWrapper'
+import { LambdaOptions } from './lambda'
+import { log, getReadableFileSize } from './logUtils'
+
+type RuntimeLanguage = 'java' | 'python'
+
+type FilterLambdas = {
+  runtimes: RuntimeLanguage[]
+  filterText?: string
+}
+
+/**
+ *
+ * @param fucntions all user lambdas
+ * @param options filter values: runtime / free text
+ * @returns
+ */
+const printAvailableLambdas = (
+  fucntions: FunctionConfiguration[] = [],
+  options: FilterLambdas
+) => {
+  const { runtimes, filterText = '' } = options
+  const searchValue = filterText?.trim().toLowerCase()
+
+  const filteredFunctions = fucntions
+    .filter(f => runtimes.some(r => f.Runtime?.includes(r)))
+    .filter(f => f.FunctionName?.toLowerCase().includes(searchValue))
+  log(
+    i18n.__('availableForScan', {
+      icon: logSymbols.success,
+      count: `${filteredFunctions.length}`
+    })
+  )
+  const groupByRuntime = groupBy(filteredFunctions, 'Runtime')
+
+  Object.entries(groupByRuntime).forEach(([runtime, arr]) => {
+    const sorted = sortBy(arr, 'FunctionName')
+    const count = `${arr.filter(a => a.Runtime === runtime).length}`
+
+    log(chalk.gray(i18n.__('runtimeCount', { runtime, count })))
+    sorted.forEach(f => {
+      const size = f.CodeSize ? getReadableFileSize(f.CodeSize) : ''
+      log(`${f.FunctionName} ${chalk.gray(`(${size})`)}`)
+    })
+  })
+}
+
+/**
+ *
+ * @param lambdaOptions to create lambdaClient
+ * @returns list of all user lambdas that availbale to scan
+ */
+const getAllLambdas = async (lambdaOptions: LambdaOptions) => {
+  const functions: FunctionConfiguration[] = []
+  const spinner = ora.returnOra(i18n.__('loadingFunctionList'))
+
+  try {
+    const client = getLambdaClient(lambdaOptions)
+    const command = new ListFunctionsCommand({})
+
+    ora.startSpinner(spinner)
+
+    const data = await client.send(command)
+    const { Functions } = data
+    let { NextMarker } = data
+
+    if (!Functions?.length) {
+      ora.failSpinner(spinner, i18n.__('noFunctionsFound'))
+      return
+    }
+
+    functions.push(...Functions)
+    spinner.text = i18n.__('functionsFound', { count: `${functions.length}` })
+
+    // pagination on functions
+    while (NextMarker) {
+      command.input.Marker = NextMarker
+      const chank = await client.send(command)
+
+      if (chank.Functions?.length) {
+        functions.push(...chank.Functions)
+        spinner.text = i18n.__('functionsFound', {
+          count: `${functions.length}`
+        })
+      }
+
+      NextMarker = chank.NextMarker
+    }
+
+    ora.succeedSpinner(
+      spinner,
+      i18n.__('functionsFound', { count: `${functions.length}` })
+    )
+  } catch (error) {
+    ora.failSpinner(spinner, i18n.__('failedToLoadFunctions'))
+    throw error
+  }
+
+  return functions
+}
+
+export { getAllLambdas, printAvailableLambdas }

package/src/lambda/logUtils.ts

@@ -43,4 +43,22 @@ const prettyPrintJson = (obj: string | any, depth: number | null = null) => {
   console.log(util.inspect(objToPrint, { colors: true, depth }))
 }
 
-export { log, prettyPrintJson }
+/**
+ *
+ * @param fileSizeInBytes
+ *
+ * @returns human readable format
+ */
+const getReadableFileSize = (fileSizeInBytes: number) => {
+  let i = -1
+  const byteUnits = [' kB', ' MB', ' GB', ' TB', 'PB', 'EB', 'ZB', 'YB']
+
+  do {
+    fileSizeInBytes = fileSizeInBytes / 1024
+    i++
+  } while (fileSizeInBytes > 1024)
+
+  return Math.max(fileSizeInBytes, 0.1).toFixed(1) + byteUnits[i]
+}
+
+export { log, prettyPrintJson, getReadableFileSize }

package/src/lambda/scanDetailCompletion.ts

@@ -1,3 +1,4 @@
+import i18n from 'i18n'
 import { sleep } from '../utils/requestUtils'
 import { getHttpClient } from '../utils/commonApi'
 import { ApiParams } from './lambda'
@@ -35,9 +36,8 @@ const pollScanUntilCompletion = async (
   const client = getHttpClient(config)
 
   const activeStatuses = ['PENDING', 'SCANNING', 'QUEUED']
-  const startedText = 'Scan started'
   const maxEndTime = new Date().getTime() + timeoutInMinutes * MS_IN_MINUTE
-  const startScanSpinner = ora.returnOra(startedText)
+  const startScanSpinner = ora.returnOra(i18n.__('scanStarted'))
   ora.startSpinner(startScanSpinner)
 
   await sleep(5000) // wait 5 sec before first polling
@@ -62,12 +62,12 @@ const pollScanUntilCompletion = async (
 
       await sleep(2 * 1000)
     } catch (error) {
-      ora.failSpinner(startScanSpinner, 'Scan Failed')
+      ora.failSpinner(startScanSpinner, i18n.__('scanFailed'))
       throw error
     }
 
     if (Date.now() >= maxEndTime) {
-      ora.failSpinner(startScanSpinner, 'Scan timed out')
+      ora.failSpinner(startScanSpinner, i18n.__('scanTimedOut'))
       throw new CliError(ERRORS.FAILED_TO_GET_SCAN, {
         errorCode: 'waitingTimedOut'
       })