@contrast/contrast 2.0.2-beta.2 → 2.0.2-beta.4

package/src/lambda/lambda.ts

@@ -1,230 +0,0 @@
-import commandLineArgs from 'command-line-args'
-import { performance } from 'perf_hooks'
-import { kebabCase } from 'lodash'
-import i18n from 'i18n'
-import { getAuth } from '../utils/paramsUtil/paramHandler'
-import { CliError } from './cliError'
-import { ERRORS } from './constants'
-import { lambdaUsageGuide } from './help'
-import { log } from './logUtils'
-import { pollScanUntilCompletion } from './scanDetailCompletion'
-import { requestScanFunctionPost } from './scanRequest'
-import { getScanResults } from './scanResults'
-import { printResults } from './utils'
-import { getAllLambdas, printAvailableLambdas } from './lambdaUtils'
-import { sleep } from '../utils/requestUtils'
-import ora from '../utils/oraWrapper'
-import { postAnalytics } from './analytics'
-import { LambdaOptions, AnalyticsOption, StatusType, EventType } from './types'
-import { APP_VERSION } from '../constants/constants'
-import { postRunMessage } from '../common/commonHelp'
-
-type ApiParams = {
-  organizationId: string
-  provider: 'aws'
-  accountId: string
-}
-
-const failedStates = [
-  'UNSUPPORTED',
-  'EXCLUDED',
-  'CANCELED',
-  'FAILED',
-  'DISMISSED'
-]
-
-const printHelpMessage = () => {
-  log(lambdaUsageGuide)
-}
-
-const getLambdaOptions = (argv: string[]) => {
-  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[]) => {
-  let errorMsg
-  let scanInfo: { functionArn: string; scanId: string } | undefined
-  const commandSessionId = Date.now().toString(36)
-  try {
-    const lambdaOptions = getLambdaOptions(argv)
-    const { help } = lambdaOptions
-    const startCommandAnalytics: AnalyticsOption = {
-      arguments: lambdaOptions,
-      sessionId: commandSessionId,
-      eventType: EventType.START,
-      packageVersion: APP_VERSION
-    }
-    postAnalytics(startCommandAnalytics).catch((error: Error) => {
-      /* ignore */
-    })
-    if (help) {
-      return handleLambdaHelp()
-    }
-
-    validateRequiredLambdaParams(lambdaOptions)
-
-    if (lambdaOptions.listFunctions) {
-      await getAvailableFunctions(lambdaOptions)
-    } else {
-      scanInfo = await actualProcessLambda(lambdaOptions)
-    }
-  } catch (error) {
-    if (error instanceof CliError) {
-      errorMsg = error.getErrorMessage()
-    } else if (error instanceof Error) {
-      errorMsg = error.message
-    }
-  } finally {
-    const endCommandAnalytics: AnalyticsOption = {
-      sessionId: commandSessionId,
-      eventType: EventType.END,
-      status: errorMsg ? StatusType.FAILED : StatusType.SUCCESS,
-      packageVersion: APP_VERSION
-    }
-    if (errorMsg) {
-      endCommandAnalytics.errorMsg = errorMsg
-      console.error(errorMsg)
-    }
-    if (scanInfo) {
-      endCommandAnalytics.scanFunctionData = scanInfo
-    }
-    await postAnalytics(endCommandAnalytics).catch((error: Error) => {
-      /* ignore */
-    })
-
-    postRunMessage('lambda')
-
-    if (errorMsg) {
-      process.exit(1)
-    }
-  }
-}
-
-const getAvailableFunctions = async (lambdaOptions: LambdaOptions) => {
-  const lambdas = await getAllLambdas(lambdaOptions)
-  printAvailableLambdas(lambdas, {
-    runtimes: ['python', 'java', 'node', 'dotnet']
-  })
-}
-
-const actualProcessLambda = async (lambdaOptions: LambdaOptions) => {
-  const auth = getAuth()
-  const startTime = performance.now()
-  const { jsonOutput } = lambdaOptions
-  const { scanId, params, functionArn } = await requestScanFunctionPost(
-    auth,
-    lambdaOptions
-  )
-  const scans = await pollScanUntilCompletion(auth, 10, params, scanId)
-  const failedScan = scans
-    ?.filter((s: any) => s.scanType === 2)
-    .find((s: any) => failedStates.includes(s.state))
-
-  if (failedScan) {
-    throw new CliError(ERRORS.FAILED_TO_GET_SCAN, {
-      statusCode: 200,
-      errorCode: failedScan.state,
-      description: failedScan.stateReasonText
-    })
-  }
-
-  // Wait to make sure we will have all the results
-  const startGetherResultsSpinner = ora.returnOra(i18n.__('gatherResults'))
-  ora.startSpinner(startGetherResultsSpinner)
-  await sleep(15 * 1000)
-  ora.succeedSpinner(startGetherResultsSpinner, 'Done gathering results')
-
-  const resultsResponse = await getScanResults(
-    auth,
-    params,
-    scanId,
-    functionArn
-  )
-
-  if (jsonOutput) {
-    console.log(JSON.stringify(resultsResponse?.data?.results, null, 2))
-    return
-  }
-
-  const results = resultsResponse?.data?.results
-  if (!results) {
-    throw new CliError(ERRORS.FAILED_TO_GET_RESULTS, {
-      errorCode: 'missingResults'
-    })
-  }
-
-  if (!results.length) {
-    log('👏 No vulnerabilities found')
-  }
-
-  const endTime = performance.now()
-  const scanDurationMs = endTime - startTime
-
-  log(`----- Scan completed ${(scanDurationMs / 1000).toFixed(2)}s -----`)
-
-  if (results?.length) {
-    printResults(results)
-  }
-
-  return { functionArn, scanId }
-}
-
-const validateRequiredLambdaParams = (options: LambdaOptions) => {
-  if (options._unknown?.length) {
-    throw new CliError(ERRORS.VALIDATION_FAILED, {
-      description: i18n.__('notSupportedFlags', {
-        flags: options._unknown.join('\n')
-      })
-    })
-  }
-
-  if (!options?.functionName && !options?.listFunctions) {
-    throw new CliError(ERRORS.VALIDATION_FAILED, {
-      errorCode: 'missingFunctionName'
-    })
-  }
-
-  const flagsWithoutValues = Object.entries(options)
-    .filter(([, value]) => !value)
-    .map(([key]) => key)
-    .map(p => `--${kebabCase(p)}`)
-
-  if (flagsWithoutValues.length) {
-    throw new CliError(ERRORS.VALIDATION_FAILED, {
-      description: i18n.__('missingFlagArguments', {
-        flags: flagsWithoutValues.join('\n')
-      })
-    })
-  }
-}
-
-const handleLambdaHelp = () => {
-  printHelpMessage()
-  process.exit(0)
-}
-
-export { processLambda, LambdaOptions, ApiParams, getAvailableFunctions }

package/src/lambda/lambdaUtils.ts

@@ -1,111 +0,0 @@
-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' | 'node' | 'dotnet'
-
-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

@@ -1,64 +0,0 @@
-import chalk from 'chalk'
-import util from 'util'
-
-interface logStyles {
-  bold?: boolean
-  italic?: boolean
-  underline?: boolean
-  strikethrough?: boolean
-}
-
-const log = (message: string | number, styles?: logStyles) => {
-  let chalkFunction = chalk.reset
-
-  if (styles?.bold) {
-    chalkFunction = chalk.bold
-  } else if (styles?.italic) {
-    chalkFunction = chalk.italic
-  } else if (styles?.underline) {
-    chalkFunction = chalk.underline
-  } else if (styles?.strikethrough) {
-    chalkFunction = chalk.strikethrough
-  }
-
-  console.log(styles ? chalkFunction(message) : message)
-}
-
-/**
- *
- * @param obj any json object or string
- * @param depth determines how levels it will recurse to show the json
- */
-const prettyPrintJson = (obj: string | any, depth: number | null = null) => {
-  if (!obj) {
-    return
-  }
-
-  let objToPrint = obj
-
-  if (typeof obj === 'string') {
-    objToPrint = JSON.parse(obj)
-  }
-
-  console.log(util.inspect(objToPrint, { colors: true, depth }))
-}
-
-/**
- *
- * @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,78 +0,0 @@
-import i18n from 'i18n'
-import { sleep } from '../utils/requestUtils'
-import { getHttpClient } from '../utils/commonApi'
-import { ApiParams } from './lambda'
-import HTTPClient from '../common/HTTPClient'
-import ora from '../utils/oraWrapper'
-import { CliError } from './cliError'
-import { ERRORS } from './constants'
-import { ContrastConf } from '../utils/getConfig'
-
-const MS_IN_MINUTE = 1000 * 60
-
-const getScanResources = async (
-  config: ContrastConf,
-  params: ApiParams,
-  scanId: string,
-  httpClient: HTTPClient
-) => {
-  const res = await httpClient.getScanResources(config, params, scanId)
-  const { statusCode, body } = res
-
-  if (statusCode === 200) {
-    return res
-  }
-
-  const { errorCode } = body || {}
-  throw new CliError(ERRORS.FAILED_TO_GET_SCAN, { statusCode, errorCode })
-}
-
-const pollScanUntilCompletion = async (
-  config: any,
-  timeoutInMinutes: number,
-  params: ApiParams,
-  scanId: string
-) => {
-  const client = getHttpClient(config)
-
-  const activeStatuses = ['PENDING', 'SCANNING', 'QUEUED']
-  const maxEndTime = new Date().getTime() + timeoutInMinutes * MS_IN_MINUTE
-  const startScanSpinner = ora.returnOra(i18n.__('scanStarted'))
-  ora.startSpinner(startScanSpinner)
-
-  await sleep(5000) // wait 5 sec before first polling
-
-  let complete = false
-  while (!complete) {
-    try {
-      const result = await exports.getScanResources(
-        config,
-        params,
-        scanId,
-        client
-      )
-      const { resources: scans } = result.body.data
-      const staticScans = scans?.filter((s: any) => s.scanType === 2)
-      complete = staticScans.some((s: any) => !activeStatuses.includes(s.state))
-
-      if (complete) {
-        ora.succeedSpinner(startScanSpinner, 'Scan Finished')
-        return scans
-      }
-
-      await sleep(2 * 1000)
-    } catch (error) {
-      ora.failSpinner(startScanSpinner, i18n.__('scanFailed'))
-      throw error
-    }
-
-    if (Date.now() >= maxEndTime) {
-      ora.failSpinner(startScanSpinner, i18n.__('scanTimedOut'))
-      throw new CliError(ERRORS.FAILED_TO_GET_SCAN, {
-        errorCode: 'waitingTimedOut'
-      })
-    }
-  }
-}
-
-export { pollScanUntilCompletion, getScanResources }

package/src/lambda/scanRequest.ts

@@ -1,169 +0,0 @@
-import i18n from 'i18n'
-import logSymbols from 'log-symbols'
-import chalk from 'chalk'
-import { parseARN } from './arn'
-import {
-  getLambdaClient,
-  getLambdaFunctionConfiguration,
-  getLambdaPolicies,
-  getLayersLinks
-} from './aws'
-import { toLowerKeys } from './utils'
-import { getHttpClient } from '../utils/commonApi'
-import { ApiParams, LambdaOptions } from './lambda'
-import { log, prettyPrintJson } from './logUtils'
-import { CliError } from './cliError'
-import { ERRORS } from './constants'
-import { sleep } from '../utils/requestUtils'
-
-const MAX_RETRIES = 2
-
-const sendScanPostRequest: (
-  config: any,
-  params: ApiParams,
-  functionsEvent: unknown,
-  showProgress?: boolean,
-  retryNumber?: number
-) => any = async (
-  config,
-  params,
-  functionsEvent,
-  showProgress = false,
-  retryNumber = 0
-) => {
-  const client = getHttpClient(config)
-
-  if (showProgress) {
-    log(i18n.__('sendingScanRequest', { icon: logSymbols.success }))
-  }
-
-  const res = await client.postFunctionScan(config, params, functionsEvent)
-  const { statusCode, body } = res
-
-  if (statusCode === 201) {
-    if (showProgress) {
-      log(i18n.__('scanRequestedSuccessfully', { icon: logSymbols.success }))
-    }
-
-    return body?.data?.scanId
-  }
-
-  let { errorCode } = body?.data || {}
-  const { data } = body?.data || {}
-
-  let description = ''
-  switch (errorCode) {
-    case 'not_supported_runtime':
-      description = i18n.__(errorCode, {
-        runtime: data?.runtime,
-        supportedRuntimes: data?.supportedRuntimes.sort().join(' | ')
-      })
-      errorCode = false
-      break
-    case 'not_supported_lambda':
-      description = i18n.__(errorCode)
-      errorCode = false
-      break
-    default:
-      if (retryNumber < MAX_RETRIES) {
-        await sleep(3 * 1000)
-        return sendScanPostRequest(
-          config,
-          params,
-          functionsEvent,
-          showProgress,
-          retryNumber + 1
-        )
-      }
-  }
-
-  throw new CliError(ERRORS.FAILED_TO_START_SCAN, {
-    statusCode,
-    errorCode,
-    data,
-    description
-  })
-}
-
-const createFunctionEvent = (
-  lambdaConfig: any,
-  layersLinks: any,
-  lambdaPolicies: any
-) => {
-  delete lambdaConfig.$metadata
-
-  const functionEvent = toLowerKeys(lambdaConfig.Configuration)
-  functionEvent['code'] = lambdaConfig.Code
-  functionEvent['rolePolicies'] = lambdaPolicies
-
-  if (layersLinks) {
-    functionEvent['layers'] = layersLinks
-  }
-
-  return { function: functionEvent }
-}
-
-const requestScanFunctionPost = async (
-  config: any,
-  lambdaOptions: LambdaOptions
-) => {
-  const { verbose, jsonOutput, functionName } = lambdaOptions
-  const lambdaClient = getLambdaClient(lambdaOptions)
-
-  if (!jsonOutput) {
-    log(
-      i18n.__('fetchingConfiguration', {
-        icon: logSymbols.success,
-        functionName: chalk.bold(functionName)
-      })
-    )
-  }
-
-  const lambdaConfig = await getLambdaFunctionConfiguration(
-    lambdaClient,
-    lambdaOptions
-  )
-  if (!lambdaConfig?.Configuration) {
-    throw new CliError(ERRORS.FAILED_TO_START_SCAN, {
-      errorCode: 'missingLambdaConfig'
-    })
-  }
-  const { Configuration } = lambdaConfig
-  const layersLinks = await getLayersLinks(lambdaClient, Configuration)
-  const lambdaPolicies = await getLambdaPolicies(Configuration, lambdaOptions)
-
-  const functionEvent = createFunctionEvent(
-    lambdaConfig,
-    layersLinks,
-    lambdaPolicies
-  )
-  const { FunctionArn: functionArn } = Configuration
-  if (!functionArn) {
-    throw new CliError(ERRORS.FAILED_TO_START_SCAN, {
-      errorCode: 'missingLambdaArn'
-    })
-  }
-
-  const parsedARN = parseARN(functionArn)
-  const params: ApiParams = {
-    organizationId: config.organizationId,
-    provider: 'aws',
-    accountId: parsedARN.accountId
-  }
-
-  if (verbose) {
-    log(i18n.__('fetchedConfiguration', { icon: logSymbols.success }))
-    prettyPrintJson(functionEvent)
-  }
-
-  const scanId = await sendScanPostRequest(
-    config,
-    params,
-    functionEvent,
-    !jsonOutput
-  )
-
-  return { scanId, params, functionArn }
-}
-
-export { sendScanPostRequest, requestScanFunctionPost, createFunctionEvent }

package/src/lambda/scanResults.ts

@@ -1,29 +0,0 @@
-import { getHttpClient } from '../utils/commonApi'
-import { CliError } from './cliError'
-import { ERRORS } from './constants'
-import { ApiParams } from './lambda'
-
-const getScanResults = async (
-  config: any,
-  params: ApiParams,
-  scanId: string,
-  functionArn: string
-) => {
-  const client = getHttpClient(config)
-
-  const { statusCode, body } = await client.getFunctionScanResults(
-    config,
-    params,
-    scanId,
-    functionArn
-  )
-
-  if (statusCode === 200) {
-    return body
-  }
-
-  const { errorCode } = body || {}
-  throw new CliError(ERRORS.FAILED_TO_GET_RESULTS, { statusCode, errorCode })
-}
-
-export { getScanResults }