@contrast/contrast 1.0.0 → 1.0.3

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'
       })

package/src/lambda/scanRequest.ts

@@ -24,8 +24,7 @@ const sendScanPostRequest = async (
   const client = getHttpClient(config)
 
   if (showProgress) {
-    // prettier-ignore
-    log(`${logSymbols.success} Sending Lambda Function scan request to Contrast`)
+    log(i18n.__('sendingScanRequest', { icon: logSymbols.success }))
   }
 
   const res = await client.postFunctionScan(config, params, functionsEvent)
@@ -33,7 +32,7 @@ const sendScanPostRequest = async (
 
   if (statusCode === 201) {
     if (showProgress) {
-      log(`${logSymbols.success} Scan requested successfully`)
+      log(i18n.__('scanRequestedSuccessfully', { icon: logSymbols.success }))
     }
 
     return body?.data?.scanId
@@ -45,11 +44,10 @@ const sendScanPostRequest = async (
   let description = ''
   switch (errorCode) {
     case 'not_supported_runtime':
-      description = i18n.__(
-        errorCode,
-        data?.runtime,
-        data?.supportedRuntimes.sort().join(' | ')
-      )
+      description = i18n.__(errorCode, {
+        runtime: data?.runtime,
+        supportedRuntimes: data?.supportedRuntimes.sort().join(' | ')
+      })
       errorCode = false
       break
   }
@@ -88,8 +86,12 @@ const requestScanFunctionPost = async (
   const lambdaClient = getLambdaClient(lambdaOptions)
 
   if (!jsonOutput) {
-    // prettier-ignore
-    log(`${logSymbols.success} Fetching configuration and policies for Lambda Function ${chalk.bold(functionName)}`)
+    log(
+      i18n.__('fetchingConfiguration', {
+        icon: logSymbols.success,
+        functionName: chalk.bold(functionName)
+      })
+    )
   }
 
   const lambdaConfig = await getLambdaFunctionConfiguration(
@@ -125,7 +127,7 @@ const requestScanFunctionPost = async (
   }
 
   if (verbose) {
-    log(`${logSymbols.success} Fetched configuration from AWS:`)
+    log(i18n.__('fetchedConfiguration', { icon: logSymbols.success }))
     prettyPrintJson(functionEvent)
   }