@icure/api 7.1.5 → 7.1.6

package/icc-x-api/utils/asn1-packer.ts

@@ -0,0 +1,87 @@
+// Copyright 2018 AJ ONeal. All rights reserved
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Ported to Typescript by iCure sa */
+
+const numToHex = function (d: number): string {
+  const ds = d.toString(16)
+  if (ds.length % 2) {
+    return '0' + ds
+  }
+  return ds
+}
+
+//
+// Packer
+//
+// Almost every ASN.1 type that's important for CSR
+// can be represented generically with only a few rules.
+export function packOther(...args: string[]) {
+  const typ: string = args.shift()!
+  const str: string = args.join('').replace(/\s+/g, '').toLowerCase()
+  var len: number = str.length / 2
+  var lenlen = 0
+  var hex = typ
+
+  // We can't have an odd number of hex chars
+  if (len !== Math.round(len)) {
+    throw new Error('invalid hex')
+  }
+
+  // The first byte of any ASN.1 sequence is the type (Sequence, Integer, etc)
+  // The second byte is either the size of the value, or the size of its size
+  // 1. If the second byte is < 0x80 (128) it is considered the size
+  // 2. If it is > 0x80 then it describes the number of bytes of the size
+  //    ex: 0x82 means the next 2 bytes describe the size of the value
+  // 3. The special case of exactly 0x80 is "indefinite" length (to end-of-file)
+  if (len > 127) {
+    lenlen += 1
+    while (len > 255) {
+      lenlen += 1
+      len = len >> 8
+    }
+  }
+
+  if (lenlen) {
+    hex += numToHex(0x80 + lenlen)
+  }
+  return hex + numToHex(str.length / 2) + str
+}
+
+// The Integer type has some special rules
+function packUInt(...arr: string[]) {
+  const str = arr.join('')
+  const first = parseInt(str.slice(0, 2), 16)
+
+  // If the first byte is 0x80 or greater, the number is considered negative
+  // Therefore we add a '00' prefix if the 0x80 bit is set
+  return 0x80 & first ? packOther('02', '00' + str) : packOther('02', str)
+}
+
+// The Bit String type also has a special rule
+function packBitStr(...arr: string[]) {
+  var str = arr.join('')
+  // '00' is a mask of how many bits of the next byte to ignore
+  return packOther('03', '00' + str)
+}
+
+export type Asn1Item = number | string | Asn1Item[]
+
+export function pack(arr: Asn1Item[]) {
+  var typ = numToHex(arr[0] as number)
+  var str = ''
+  if (arr[1]) {
+    if (Array.isArray(arr[1])) {
+      arr[1].forEach((a) => (str += pack(a as Asn1Item[])))
+    } else if ('string' === typeof arr[1]) {
+      str = arr[1]
+    } else {
+      throw new Error('unexpected item')
+    }
+  }
+  const packed = '03' === typ ? packBitStr(str) : '02' === typ ? packUInt(str) : packOther(typ, str)
+
+  return packed
+}

package/icc-x-api/utils/asn1-parser.ts

@@ -0,0 +1,151 @@
+// Copyright 2018 AJ ONeal. All rights reserved
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+//
+// Parser
+//
+
+// Although I've only seen 9 max in https certificates themselves,
+// but each domain list could have up to 100
+const ELOOPN = 102
+const ELOOP = 'ujs Error: iterated over ' + ELOOPN + '+ elements (probably a malformed file)'
+// I've seen https certificates go 29 deep
+const EDEEPN = 60
+const EDEEP = 'ujs Error: element nested ' + EDEEPN + '+ layers deep (probably a malformed file)'
+// Container Types are Sequence 0x30, Container Array? (0xA0, 0xA1)
+// Value Types are Boolean 0x01, Integer 0x02, Null 0x05, Object ID 0x06, String 0x0C, 0x16, 0x13, 0x1e Value Array? (0x82)
+// Bit String (0x03) and Octet String (0x04) may be values or containers
+// Sometimes Bit String is used as a container (RSA Pub Spki)
+const CTYPES = [0x30, 0x31, 0xa0, 0xa1]
+const VTYPES = [0x01, 0x02, 0x05, 0x06, 0x0c, 0x82]
+
+const numToHex = (d: number) => {
+  const dh = d.toString(16)
+  if (dh.length % 2) {
+    return '0' + dh
+  }
+  return dh
+}
+
+const bufToHex = (u8: Uint8Array) => {
+  var hex = []
+  var i, h
+  var len = u8.byteLength || u8.length
+
+  for (i = 0; i < len; i += 1) {
+    h = u8[i].toString(16)
+    if (h.length % 2) {
+      h = '0' + h
+    }
+    hex.push(h)
+  }
+  return hex.join('').toLowerCase()
+}
+
+const _replacer = function (k: string, v: any) {
+  if ('type' === k) {
+    return '0x' + numToHex(v)
+  }
+  if (v && 'value' === k) {
+    return '0x' + bufToHex(v.data || v)
+  }
+  return v
+}
+
+export type Asn1 = { type: number; lengthSize: number; length: number; children?: Asn1[]; value?: Uint8Array }
+
+export function parseAsn1(buf: Uint8Array, depth: number[] = [], eager: boolean = false): Asn1 {
+  if (depth.length >= EDEEPN) {
+    throw new Error(EDEEP)
+  }
+
+  var index = 2 // we know, at minimum, data starts after type (0) and lengthSize (1)
+  var asn1: Asn1 = { type: buf[0], lengthSize: 0, length: buf[1] }
+  var child
+  var iters = 0
+  var adjust = 0
+  var adjustedLen: number
+
+  // Determine how many bytes the length uses, and what it is
+  if (0x80 & asn1.length) {
+    asn1.lengthSize = 0x7f & asn1.length
+    // I think that buf->hex->int solves the problem of Endianness... not sure
+    asn1.length = parseInt(bufToHex(buf.slice(index, index + asn1.lengthSize)), 16)
+    index += asn1.lengthSize
+  }
+
+  // High-order bit Integers have a leading 0x00 to signify that they are positive.
+  // Bit Streams use the first byte to signify padding, which x.509 doesn't use.
+  if (0x00 === buf[index] && (0x02 === asn1.type || 0x03 === asn1.type)) {
+    // However, 0x00 on its own is a valid number
+    if (asn1.length > 1) {
+      index += 1
+      adjust = -1
+    }
+  }
+  adjustedLen = asn1.length + adjust
+
+  function parseChildren(eager: boolean) {
+    asn1.children = []
+    //console.warn('1 len:', (2 + asn1.lengthSize + asn1.length), 'idx:', index, 'clen:', 0);
+    while (iters < ELOOPN && index < 2 + asn1.length + asn1.lengthSize) {
+      iters += 1
+      depth.length += 1
+      child = parseAsn1(buf.slice(index, index + adjustedLen), depth, eager)
+      depth.length -= 1
+      // The numbers don't match up exactly and I don't remember why...
+      // probably something with adjustedLen or some such, but the tests pass
+      index += 2 + child.lengthSize + child.length
+      //console.warn('2 len:', (2 + asn1.lengthSize + asn1.length), 'idx:', index, 'clen:', (2 + child.lengthSize + child.length));
+      if (index > 2 + asn1.lengthSize + asn1.length) {
+        if (!eager) {
+          console.error(JSON.stringify(asn1, _replacer, 2))
+        }
+        throw new Error(
+          'Parse error: child value length (' +
+            child.length +
+            ') is greater than remaining parent length (' +
+            (asn1.length - index) +
+            ' = ' +
+            asn1.length +
+            ' - ' +
+            index +
+            ')'
+        )
+      }
+      asn1.children.push(child)
+      //console.warn(depth.join(ws) + '0x' + Enc.numToHex(asn1.type), index, 'len:', asn1.length, asn1);
+    }
+    if (index !== 2 + asn1.lengthSize + asn1.length) {
+      //console.warn('index:', index, 'length:', (2 + asn1.lengthSize + asn1.length));
+      throw new Error('premature end-of-file')
+    }
+    if (iters >= ELOOPN) {
+      throw new Error(ELOOP)
+    }
+
+    delete asn1.value
+    return asn1
+  }
+
+  // Recurse into types that are _always_ containers
+  if (-1 !== CTYPES.indexOf(asn1.type)) {
+    return parseChildren(eager)
+  }
+
+  // Return types that are _always_ values
+  asn1.value = buf.slice(index, index + adjustedLen)
+  if (-1 !== VTYPES.indexOf(asn1.type)) {
+    return asn1
+  }
+
+  // For ambigious / unknown types, recurse and return on failure
+  // (and return child array size to zero)
+  try {
+    return parseChildren(true)
+  } catch (e) {
+    asn1.children && (asn1.children.length = 0)
+    return asn1
+  }
+}

package/icc-x-api/utils/binary-utils.ts

@@ -0,0 +1,163 @@
+import { ua2string, string2ua, string2ab, ua2ab, b64_2ab, b64_2ua, ua2b64, b2a, a2b } from '../../icc-api/model/ModelHelper'
+export { ua2string, string2ua, string2ab, ua2ab, b64_2ab, b64_2ua, ua2b64, b2a, a2b }
+
+const textDecoder = typeof TextDecoder !== 'undefined' ? new TextDecoder() : null
+const textEncoder = typeof TextEncoder !== 'undefined' ? new TextEncoder() : null
+
+export function utf8_2ua(str: string): Uint8Array {
+  if (textEncoder) {
+    return textEncoder.encode(str)
+  }
+
+  const utf8 = new Uint8Array(4 * str.length)
+  let j = 0
+  for (let i = 0; i < str.length; i++) {
+    let charcode = str.charCodeAt(i)
+    if (charcode < 0x80) {
+      utf8.set([charcode], j++)
+    } else if (charcode < 0x800) {
+      utf8.set([0xc0 | (charcode >> 6), 0x80 | (charcode & 0x3f)], j)
+      j += 2
+    } else if (charcode < 0xd800 || charcode >= 0xe000) {
+      utf8.set([0xe0 | (charcode >> 12), 0x80 | ((charcode >> 6) & 0x3f), 0x80 | (charcode & 0x3f)], j)
+      j += 3
+    } else {
+      i++
+      // UTF-16 encodes 0x10000-0x10FFFF by
+      // subtracting 0x10000 and splitting the
+      // 20 bits of 0x0-0xFFFFF into two halves
+      charcode = 0x10000 + (((charcode & 0x3ff) << 10) | (str.charCodeAt(i) & 0x3ff))
+      utf8.set([0xf0 | (charcode >> 18), 0x80 | ((charcode >> 12) & 0x3f), 0x80 | ((charcode >> 6) & 0x3f), 0x80 | (charcode & 0x3f)], j)
+      j += 4
+    }
+  }
+  return utf8.subarray(0, j)
+}
+
+/**
+ * Uint8Array/ArrayBuffer to utf-8 strring
+ * @param _ua {Uint8Array} or ArrayBuffer
+ * @returns {String} a UTF-8 encoded string
+ */
+export function ua2utf8(_ua: Uint8Array | ArrayBuffer): string {
+  if (textDecoder) {
+    // if _ua is undefined, imitate the JS implementation below which returns an empty string
+    return _ua ? textDecoder.decode(_ua) : ''
+  }
+
+  let out, i, len, c, u
+  let char2, char3, char4
+
+  // avoid applying the Uint8Array constructor: on ArrayBuffer it creates a
+  // view but on Uint8Array it creates a copy
+  const array = ArrayBuffer.isView(_ua) ? _ua : new Uint8Array(_ua)
+
+  out = ''
+  len = array.length || array.byteLength
+  i = 0
+  while (i < len) {
+    c = array[i++]
+    switch (c >> 4) {
+      case 0:
+      case 1:
+      case 2:
+      case 3:
+      case 4:
+      case 5:
+      case 6:
+      case 7:
+        // 0xxxxxxx
+        out += String.fromCharCode(c)
+        break
+      case 12:
+      case 13:
+        // 110x xxxx   10xx xxxx
+        char2 = array[i++]
+        out += String.fromCharCode(((c & 0x1f) << 6) | (char2 & 0x3f))
+        break
+      case 14:
+        // 1110 xxxx  10xx xxxx  10xx xxxx
+        char2 = array[i++]
+        char3 = array[i++]
+        out += String.fromCharCode(((c & 0x0f) << 12) | ((char2 & 0x3f) << 6) | ((char3 & 0x3f) << 0))
+        break
+      case 15:
+        // 1111 xxxx  10xx xxxx  10xx xxxx  10xx xxxx
+        char2 = array[i++]
+        char3 = array[i++]
+        char4 = array[i++]
+        u = ((c & 0x07) << 18) | ((char2 & 0x3f) << 12) | ((char3 & 0x3f) << 6) | (((char4 & 0x3f) << 0) - 0x10000)
+        out += String.fromCharCode(0xd800 + (u >> 10))
+        out += String.fromCharCode(0xdc00 + (u & 1023))
+        break
+    }
+  }
+
+  return out
+}
+
+export function hex2ua(s: string): Uint8Array {
+  const ua = new Uint8Array(s.length / 2)
+  s = s.toLowerCase()
+  for (let i = 0; i < s.length; i += 2) {
+    ua[i / 2] =
+      (s.charCodeAt(i) < 58 ? s.charCodeAt(i) - 48 : s.charCodeAt(i) - 87) * 16 +
+      (s.charCodeAt(i + 1) < 58 ? s.charCodeAt(i + 1) - 48 : s.charCodeAt(i + 1) - 87)
+  }
+  return ua
+}
+
+/**
+ * Uint8Array/ArrayBuffer to hex String
+ *
+ * @param _ua {Uint8Array} or ArrayBuffer
+ * @returns {String} Hex String
+ */
+export function ua2hex(_ua: Uint8Array | ArrayBuffer): string {
+  let s = ''
+  const ua = new Uint8Array(_ua)
+  for (let i = 0; i < ua.length; i++) {
+    const hhb = (ua[i] & 0xf0) >> 4
+    const lhb = ua[i] & 0x0f
+    s += String.fromCharCode(hhb > 9 ? hhb + 87 : hhb + 48)
+    s += String.fromCharCode(lhb > 9 ? lhb + 87 : lhb + 48)
+  }
+
+  return s
+}
+
+export function b64_2uas(s: string): Array<Uint8Array> {
+  const sliceSize = 1024
+  const byteCharacters = a2b(s)
+  const bytesLength = byteCharacters.length
+  const slicesCount = Math.ceil(bytesLength / sliceSize)
+  const byteArrays = new Array(slicesCount)
+
+  for (let sliceIndex = 0; sliceIndex < slicesCount; ++sliceIndex) {
+    const begin = sliceIndex * sliceSize
+    const end = Math.min(begin + sliceSize, bytesLength)
+
+    const bytes = new Array(end - begin)
+    for (let offset = begin, i = 0; offset < end; ++i, ++offset) {
+      bytes[i] = byteCharacters[offset].charCodeAt(0)
+    }
+    byteArrays[sliceIndex] = new Uint8Array(bytes)
+  }
+  return byteArrays
+}
+
+export function ua2b64Url(ua: Uint8Array | ArrayBuffer): string {
+  return ua2b64(ua).replace(/\+/g, '-').replace(/\//g, '_').replace(/=/g, '')
+}
+
+export function b64Url2ua(ua: string): ArrayBuffer {
+  return b64_2ua(ua.replace(/-/g, '+').replace(/_/g, '/').replace(/=/g, '') + (ua.length % 4 === 3 ? '=' : ua.length % 4 === 2 ? '==' : ''))
+}
+
+export function hex2string(hexStr: string): string {
+  return ua2string(hex2ua(hexStr))
+}
+
+export function string2hex(text: string): string {
+  return ua2hex(string2ua(text))
+}

package/icc-x-api/utils/code-util.ts

@@ -0,0 +1,39 @@
+import * as _ from 'lodash'
+
+import { Code } from '../../icc-api/model/Code'
+
+/**
+ * Normalizes the code's four main fields (type, code, version and id). The first three are considered to be
+ * authoritative, while the id is a pure function of them. The authoritative fields are filled in from the id if
+ * missing, or the version is set to '1' if it is the only missing authoritative field. The id is then rederived from
+ * the three fields.
+ * @param code The code to normalize.
+ * @returns A shallow copy of the input with its type, code, version and id normalized.
+ */
+export function normalizeCode(code: Code): Code {
+  code = _.clone(code)
+
+  if (code.type && code.code && code.version) {
+    // do nothing, we all have the authoritative fields we need
+  } else if (code.id) {
+    // reconstruct the authoritative fields from the id
+    const [idType, idCode, idVersion, ...idRest] = code.id.split('|')
+    if (idType && idCode && idVersion && idRest.length === 0) {
+      if (!code.type) code.type = idType
+      if (!code.code) code.code = idCode
+      if (!code.version) code.version = idVersion
+    } else {
+      throw new Error(`attempted to normalize from a malformed code id "${code.id}"`)
+    }
+  } else if (code.type && code.code && !code.version) {
+    // we can provide a default value
+    code.version = '1'
+  } else {
+    throw new Error('could not reconstruct the code')
+  }
+
+  // Recompute the id to ensure that it matches the reconstructed code.
+  code.id = `${code.type}|${code.code}|${code.version}`
+
+  return code
+}

package/icc-x-api/utils/collection-utils.ts

@@ -0,0 +1,18 @@
+/**
+ * Check if two sets are equals (they contain the same elements). Will not work if the content can't be compared by `==`.
+ */
+export function setEquals<T>(setA: Set<T>, setB: Set<T>): boolean {
+  if (setA.size != setB.size) return false
+  return Array.from(setA).every((x) => setB.has(x))
+}
+
+/**
+ * Check if two arrays are equals (they contain the same elements). Will not work if the content can't be compared by `==`.
+ */
+export function arrayEquals<T>(arrayA: T[], arrayB: T[]): boolean {
+  if (arrayA.length != arrayB.length) return false
+  for (let i = 0; i < arrayA.length; ++i) {
+    if (arrayA[i] !== arrayB[i]) return false
+  }
+  return true
+}