Chromium Browser Extension - zkPass

Logging sensitive information such as passwords, tokens, or request details can lead to information leakage, especially if logs are exposed to unauthorized users or external systems.

In httpSession.ts, sensitive data such as request objects were logged without redaction, increasing the risk of data exposure.

export default async function TPT(props: TPTProps) {
  const { nodeInfo, requests, condition, clientMsgEncKey, nodeMsgDecKey } = props

  const allResponse: any[] = []
  let attrIndexArr: number[] = []
  const publicFields: any[] = []
  const result: ResponseVerifyInfo[] = []
  const privateDataList: any = []
  let i = 0
  while (i < requests.length) {
    console.log('******************START SEND REQUEST*************************')
    const request = requests[i]
    const api = condition.APIs[i]
    const requestInfo = buildRequestInfo(api, request.header, request.body, allResponse)
    const tls = new TlsClient(requestInfo.host)
    tls.setServerNodeInfo(nodeInfo.host, nodeInfo.tid, clientMsgEncKey, nodeMsgDecKey)
    const res: any = await tls.send(requestInfo.text, requestInfo.accept)
    console.log('tls response info', res)
    checkResponseStatus(res.responseStatus)
    if (res.accept?.indexOf('application/json') > -1 && api.assert) {
      const { indexArr, assert } = formatAssertAndCheckValue(res.json, {
        assert: api.assert,
        HRCondition: condition.HRCondition,
      })
      api.assert = assert
      attrIndexArr = attrIndexArr.concat(indexArr)
    }

Avoid logging sensitive data, or ensure that logs are securely stored, and sensitive information is redacted or encrypted before logging.

SOLVED: The zkPass team reduced significantly the number of output logs on the console, keeping some of them until they have a final stable version of the code.

Poor key management, such as failing to validate key lengths or integrity, can lead to insecure cryptographic operations, exposing the application to brute-force attacks or misuse of weak keys.

In salsa.js, cryptographic keys were used without validation of their length or integrity, increasing the risk of weak key usage.

export function Salsa20(key, data){
  // sigma is Salsa's constant "expand 32-byte k"
  const sigma = new Uint8Array([ 101, 120, 112, 97, 110, 100, 32, 51, 50, 45, 98, 121, 116, 101, 32, 107 ])
  const out = new Uint8Array(16)
  core_salsa20(out, data, key, sigma)
  return out

Implement key length validation and ensure proper key management practices. Use libraries that handle key validation and provide secure key exchange mechanisms.

SOLVED: The zkPass team removed the vulnerable code from the code.

Storing sensitive information, such as session data, without encryption can expose it to unauthorized access if the storage mechanism is compromised.

In storage.ts, session data was stored in chrome.storage.session without encryption, which could expose user session data to potential theft or modification.

export async function setSessionStorage(keyMap: any) {
  return await chrome.storage.session.set(keyMap)
}

Always encrypt sensitive data before storing it, even in browser storage, to prevent unauthorized access.

RISK ACCEPTED: The zkPass team stated: "As for the issue mentioned in 6.4, we carefully reviewed it and found that we are only saving the program’s running state and intermediate processes, without involving any user privacy data (the source data is public), so we did not perform encryption."

Failing to validate or sanitize data before handling it in event listeners can expose applications to malicious inputs or unwanted behavior through injection attacks.

In listeners.ts, incoming messages were handled without validation, leaving the application vulnerable to malicious messages that could manipulate internal states.

chrome.runtime.onMessage.addListener(async (request) => {
  if (!request) {
    return
  }
  dispatchEvent(request)
  return true
})

Implement strict validation and sanitation for all incoming event messages, especially those originating from external or user-controlled sources.

SOLVED: The zkPass team solved the issue by adding a function to sanitize the request object before performing any operation on the object.

Parsing JSON without validation can lead to the processing of malicious or malformed data, which may result in injection attacks or unexpected behavior.

In jsonParse.ts, JSON data from responses were parsed without validation, making the application vulnerable to manipulation through malicious JSON inputs.

function genNodeParams(response: TlsResponse, api: API) {
  console.log('-----genNodeParams-----')
  const { records, fullResponse, responseSliceList, requestInfo, accept } = response

  const resStruct = genDataStruct(responseSliceList, api, accept)

  console.log('-----response struct-----', resStruct)
  console.log('-----records-----', records)
  console.log('-----record length-----', records.length)

Implement validation and sanitization checks when parsing JSON data, especially when working with untrusted input or external sources.

RISK ACCEPTED: The zkPass team stated: "Since our JSON properties and structure are not fixed, we only validated the JSON’s legality."

Manipulating URLs without proper validation or sanitation can lead to security issues such as URL injection, redirection attacks, or request forgery.

In request.ts, URLs were split and manipulated without validation, which could be exploited for URL injection or improper URL handling.

export function buildRequestInfo(api: API, header: any, body: any, dependResponse: any[]): RequestInfo {
  let { url, requestHeaders } = header
  const { method } = header
  const { requestBody } = body
  const verifyFieldPosition: any = {}
  console.log("dependResponse-------", dependResponse)
  console.log("header url-------", url)
  const host = api.host || url.split("/").slice(2, 3)[0]
  url = '/' + url.split("/").slice(3).join("/")
  const end = url.indexOf("?") > -1 ? url.indexOf("?") : url.length

  let query = pickQueryParams(url.substring(end + 1))

  url = url.substring(0, end)

Ensure proper validation and sanitization of URLs before performing operations on them to prevent injection or manipulation attacks.

SOLVED: The zkPass team added a signature verification during the execution, and added as an extra layer of security URL's validation.

Multiple outdated packages were identified in the extension, which could significantly increase the risk of security vulnerabilities. These outdated dependencies may contain known security flaws that have been publicly disclosed, leaving the extension vulnerable to a variety of potential attacks. Exploiting these vulnerabilities could lead to issues such as unauthorized access, data breaches, or even complete compromise of the system. By continuing to use outdated packages, the extension may miss out on critical security patches and performance improvements provided by more recent versions, thereby increasing the overall attack surface of the application.

Ensure that all dependencies are updated to the latest stable versions. Use your package manager to check for available updates and apply them. Regular updates would ensure that your extension benefits from the latest security patches and performance improvements.

RISK ACCEPTED: The zkPass team stated: "During the upgrade process, we discovered a large number of package incompatibilities, so we have decided not to proceed with the upgrade for now."

TLS 1.2 is still secure but lacks some security enhancements and optimizations of TLS 1.3, including better encryption methods, forward secrecy, and reduced latency.

export default class TlsClient {
  constructor(host, tls_version = TLS_VERSION.TLS_1_2) {
    this.handshake_messages = new Buffer()
    this.tls_version = tls_version
    this.host = host
    this.params = new HandshakeParameters()
    this.records = []
    this.appData = ''
    this.appDataLen = -3
    this.acceptType = ''

Upgrade to TLS 1.3 to benefit from stronger encryption, forward secrecy, and reduced handshake latency. If TLS 1.2 must be used, ensure that only secure ciphers are enabled (e.g., AES-GCM or ChaCha20-Poly1305) and that weaker algorithms (like RSA key exchange) are disabled.

PENDING: The zkPass team stated: "For the support of TLS 1.3 mentioned in 6.9, it is included in our future development plans and will not be handled in the current version."