lib0 0.2.77 → 0.2.79

package/hash/rabin-gf2-polynomial.js

@@ -0,0 +1,379 @@
+/**
+ * The idea of the Rabin fingerprint algorithm is to represent the binary as a polynomial in a
+ * finite field (Galois Field G(2)). The polynomial will then be taken "modulo" by an irreducible
+ * polynomial of the desired size.
+ *
+ * This implementation is inefficient and is solely used to verify the actually performant
+ * implementation in `./rabin.js`.
+ *
+ * @module rabin-gf2-polynomial
+ */
+
+import * as math from '../math.js'
+import * as webcrypto from 'lib0/webcrypto'
+import * as array from '../array.js'
+import * as buffer from '../buffer.js'
+
+/**
+ * @param {number} degree
+ */
+const _degreeToMinByteLength = degree => math.floor(degree / 8) + 1
+
+/**
+ * This is a GF2 Polynomial abstraction that is not meant for production!
+ *
+ * It is easy to understand and it's correctness is as obvious as possible. It can be used to verify
+ * efficient implementations of algorithms on GF2.
+ */
+export class GF2Polynomial {
+  constructor () {
+    /**
+      * @type {Set<number>}
+      */
+    this.degrees = new Set()
+  }
+}
+
+/**
+ * From Uint8Array (MSB).
+ *
+ * @param {Uint8Array} bytes
+ */
+export const createFromBytes = bytes => {
+  const p = new GF2Polynomial()
+  for (let bsi = bytes.length - 1, currDegree = 0; bsi >= 0; bsi--) {
+    const currByte = bytes[bsi]
+    for (let i = 0; i < 8; i++) {
+      if (((currByte >>> i) & 1) === 1) {
+        p.degrees.add(currDegree)
+      }
+      currDegree++
+    }
+  }
+  return p
+}
+
+/**
+ * Transform to Uint8Array (MSB).
+ *
+ * @param {GF2Polynomial} p
+ * @param {number} byteLength
+ */
+export const toUint8Array = (p, byteLength = _degreeToMinByteLength(getHighestDegree(p))) => {
+  const buf = buffer.createUint8ArrayFromLen(byteLength)
+  /**
+   * @param {number} i
+   */
+  const setBit = i => {
+    const bi = math.floor(i / 8)
+    buf[buf.length - 1 - bi] |= (1 << (i % 8))
+  }
+  p.degrees.forEach(setBit)
+  return buf
+}
+
+/**
+ * Create from unsigned integer (max 32bit uint) - read most-significant-byte first.
+ *
+ * @param {number} uint
+ */
+export const createFromUint = uint => {
+  const buf = new Uint8Array(4)
+  for (let i = 0; i < 4; i++) {
+    buf[i] = uint >>> 8 * (3 - i)
+  }
+  return createFromBytes(buf)
+}
+
+/**
+ * Create a random polynomial of a specified degree.
+ *
+ * @param {number} degree
+ */
+export const createRandom = degree => {
+  const bs = new Uint8Array(_degreeToMinByteLength(degree))
+  webcrypto.getRandomValues(bs)
+  // Get first byte and explicitly set the bit of "degree" to 1 (the result must have the specified
+  // degree).
+  const firstByte = bs[0] | 1 << (degree % 8)
+  // Find out how many bits of the first byte need to be filled with zeros because they are >degree.
+  const zeros = 7 - (degree % 8)
+  bs[0] = ((firstByte << zeros) & 0xff) >>> zeros
+  return createFromBytes(bs)
+}
+
+/**
+ * @param {GF2Polynomial} p
+ * @return number
+ */
+export const getHighestDegree = p => array.fold(array.from(p.degrees), 0, math.max)
+
+/**
+ * Add (+) p2 int the p1 polynomial.
+ *
+ * Addition is defined as xor in F2. Substraction is equivalent to addition in F2.
+ *
+ * @param {GF2Polynomial} p1
+ * @param {GF2Polynomial} p2
+ */
+export const addInto = (p1, p2) => {
+  p2.degrees.forEach(degree => {
+    if (p1.degrees.has(degree)) {
+      p1.degrees.delete(degree)
+    } else {
+      p1.degrees.add(degree)
+    }
+  })
+}
+
+/**
+ * Or (|) p2 into the p1 polynomial.
+ *
+ * Addition is defined as xor in F2. Substraction is equivalent to addition in F2.
+ *
+ * @param {GF2Polynomial} p1
+ * @param {GF2Polynomial} p2
+ */
+export const orInto = (p1, p2) => {
+  p2.degrees.forEach(degree => {
+    p1.degrees.add(degree)
+  })
+}
+
+/**
+ * Add (+) p2 to the p1 polynomial.
+ *
+ * Addition is defined as xor in F2. Substraction is equivalent to addition in F2.
+ *
+ * @param {GF2Polynomial} p1
+ * @param {GF2Polynomial} p2
+ */
+export const add = (p1, p2) => {
+  const result = new GF2Polynomial()
+  p2.degrees.forEach(degree => {
+    if (!p1.degrees.has(degree)) {
+      result.degrees.add(degree)
+    }
+  })
+  p1.degrees.forEach(degree => {
+    if (!p2.degrees.has(degree)) {
+      result.degrees.add(degree)
+    }
+  })
+  return result
+}
+
+/**
+ * Add (+) p2 to the p1 polynomial.
+ *
+ * Addition is defined as xor in F2. Substraction is equivalent to addition in F2.
+ *
+ * @param {GF2Polynomial} p
+ */
+export const clone = (p) => {
+  const result = new GF2Polynomial()
+  p.degrees.forEach(d => result.degrees.add(d))
+  return result
+}
+
+/**
+ * Add (+) p2 to the p1 polynomial.
+ *
+ * Addition is defined as xor in F2. Substraction is equivalent to addition in F2.
+ *
+ * @param {GF2Polynomial} p
+ * @param {number} degree
+ */
+export const addDegreeInto = (p, degree) => {
+  if (p.degrees.has(degree)) {
+    p.degrees.delete(degree)
+  } else {
+    p.degrees.add(degree)
+  }
+}
+
+/**
+ * Multiply (•) p1 with p2 and store the result in p1.
+ *
+ * @param {GF2Polynomial} p1
+ * @param {GF2Polynomial} p2
+ */
+export const multiply = (p1, p2) => {
+  const result = new GF2Polynomial()
+  p1.degrees.forEach(degree1 => {
+    p2.degrees.forEach(degree2 => {
+      addDegreeInto(result, degree1 + degree2)
+    })
+  })
+  return result
+}
+
+/**
+ * Multiply (•) p1 with p2 and store the result in p1.
+ *
+ * @param {GF2Polynomial} p
+ * @param {number} shift
+ */
+export const shiftLeft = (p, shift) => {
+  const result = new GF2Polynomial()
+  p.degrees.forEach(degree => {
+    const r = degree + shift
+    r >= 0 && result.degrees.add(r)
+  })
+  return result
+}
+
+/**
+ * Computes p1 % p2. I.e. the remainder of p1/p2.
+ *
+ * @param {GF2Polynomial} p1
+ * @param {GF2Polynomial} p2
+ */
+export const mod = (p1, p2) => {
+  const maxDeg1 = getHighestDegree(p1)
+  const maxDeg2 = getHighestDegree(p2)
+  const result = clone(p1)
+  for (let i = maxDeg1 - maxDeg2; i >= 0; i--) {
+    if (result.degrees.has(maxDeg2 + i)) {
+      const shifted = shiftLeft(p2, i)
+      addInto(result, shifted)
+    }
+  }
+  return result
+}
+
+/**
+ * Computes (p^e mod m).
+ *
+ * http://en.wikipedia.org/wiki/Modular_exponentiation
+ *
+ * @param {GF2Polynomial} p
+ * @param {number} e
+ * @param {GF2Polynomial} m
+ */
+export const modPow = (p, e, m) => {
+  let result = ONE
+  while (true) {
+    if ((e & 1) === 1) {
+      result = mod(multiply(result, p), m)
+    }
+    e >>>= 1
+    if (e === 0) {
+      return result
+    }
+    p = mod(multiply(p, p), m)
+  }
+}
+
+/**
+ * Find the greatest common divisor using Euclid's Algorithm.
+ *
+ * @param {GF2Polynomial} p1
+ * @param {GF2Polynomial} p2
+ */
+export const gcd = (p1, p2) => {
+  while (p2.degrees.size > 0) {
+    const modded = mod(p1, p2)
+    p1 = p2
+    p2 = modded
+  }
+  return p1
+}
+
+/**
+ * true iff p1 equals p2
+ *
+ * @param {GF2Polynomial} p1
+ * @param {GF2Polynomial} p2
+ */
+export const equals = (p1, p2) => {
+  if (p1.degrees.size !== p2.degrees.size) return false
+  for (const d of p1.degrees) {
+    if (!p2.degrees.has(d)) return false
+  }
+  return true
+}
+
+const X = createFromBytes(new Uint8Array([2]))
+const ONE = createFromBytes(new Uint8Array([1]))
+
+/**
+ * Computes ( x^(2^p) - x ) mod f
+ *
+ * (shamelessly copied from
+ * https://github.com/opendedup/rabinfingerprint/blob/master/src/org/rabinfingerprint/polynomial/Polynomial.java)
+ *
+ * @param {GF2Polynomial} f
+ * @param {number} p
+ */
+const reduceExponent = (f, p) => {
+  // compute (x^q^p mod f)
+  const q2p = math.pow(2, p)
+  const x2q2p = modPow(X, q2p, f)
+  // subtract (x mod f)
+  return mod(add(x2q2p, X), f)
+}
+
+/**
+ * BenOr Reducibility Test
+ *
+ * Tests and Constructions of Irreducible Polynomials over Finite Fields
+ * (1997) Shuhong Gao, Daniel Panario
+ *
+ * http://citeseer.ist.psu.edu/cache/papers/cs/27167/http:zSzzSzwww.math.clemson.eduzSzfacultyzSzGaozSzpaperszSzGP97a.pdf/gao97tests.pdf
+ *
+ * @param {GF2Polynomial} p
+ */
+export const isIrreducibleBenOr = p => {
+  const degree = getHighestDegree(p)
+  for (let i = 1; i < degree / 2; i++) {
+    const b = reduceExponent(p, i)
+    const g = gcd(p, b)
+    if (!equals(g, ONE)) {
+      return false
+    }
+  }
+  return true
+}
+
+/**
+ * @param {number} degree
+ */
+export const createIrreducible = degree => {
+  while (true) {
+    const p = createRandom(degree)
+    if (isIrreducibleBenOr(p)) return p
+  }
+}
+
+/**
+ * Create a fingerprint of buf using the irreducible polynomial m.
+ *
+ * @param {Uint8Array} buf
+ * @param {GF2Polynomial} m
+ */
+export const fingerprint = (buf, m) => toUint8Array(mod(createFromBytes(buf), m), _degreeToMinByteLength(getHighestDegree(m) - 1))
+
+export class RabinPolynomialEncoder {
+  /**
+   * @param {GF2Polynomial} m The irreducible polynomial
+   */
+  constructor (m) {
+    this.fingerprint = new GF2Polynomial()
+    this.m = m
+  }
+
+  /**
+   * @param {number} b
+   */
+  write (b) {
+    const bp = createFromBytes(new Uint8Array([b]))
+    const fingerprint = shiftLeft(this.fingerprint, 8)
+    orInto(fingerprint, bp)
+    this.fingerprint = mod(fingerprint, this.m)
+  }
+
+  getFingerprint () {
+    return toUint8Array(this.fingerprint, _degreeToMinByteLength(getHighestDegree(this.m) - 1))
+  }
+}

package/hash/rabin-uncached.d.ts

@@ -0,0 +1,29 @@
+export class RabinUncachedEncoder {
+    /**
+     * @param {Uint8Array} m assert(m[0] === 1)
+     */
+    constructor(m: Uint8Array);
+    m: Uint8Array;
+    blen: number;
+    bs: Uint8Array;
+    /**
+     * This describes the position of the most significant byte (starts with 0 and increases with
+     * shift)
+     */
+    bpos: number;
+    /**
+     * Add/Xor/Substract bytes.
+     *
+     * Discards bytes that are out of range.
+     * @todo put this in function or inline
+     *
+     * @param {Uint8Array} cs
+     */
+    add(cs: Uint8Array): void;
+    /**
+     * @param {number} byte
+     */
+    write(byte: number): void;
+    getFingerprint(): Uint8Array;
+}
+//# sourceMappingURL=rabin-uncached.d.ts.map

package/hash/rabin-uncached.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rabin-uncached.d.ts","sourceRoot":"","sources":["rabin-uncached.js"],"names":[],"mappings":"AAUA;IACE;;OAEG;IACH,eAFW,UAAU,EAWpB;IARC,cAAU;IACV,aAAwB;IACxB,eAAmC;IACnC;;;OAGG;IACH,aAAa;IAGf;;;;;;;OAOG;IACH,QAFW,UAAU,QAQpB;IAED;;OAEG;IACH,YAFW,MAAM,QAgBhB;IAED,6BAMC;CACF"}

package/hash/rabin-uncached.js

@@ -0,0 +1,68 @@
+/**
+ * It is not recommended to use this package. This is the uncached implementation of the rabin
+ * fingerprint algorithm. However, it can be used to verify the `rabin.js` implementation.
+ *
+ * @module rabin-uncached
+ */
+
+import * as math from '../math.js'
+import * as buffer from '../buffer.js'
+
+export class RabinUncachedEncoder {
+  /**
+   * @param {Uint8Array} m assert(m[0] === 1)
+   */
+  constructor (m) {
+    this.m = m
+    this.blen = m.byteLength
+    this.bs = new Uint8Array(this.blen)
+    /**
+     * This describes the position of the most significant byte (starts with 0 and increases with
+     * shift)
+     */
+    this.bpos = 0
+  }
+
+  /**
+   * Add/Xor/Substract bytes.
+   *
+   * Discards bytes that are out of range.
+   * @todo put this in function or inline
+   *
+   * @param {Uint8Array} cs
+   */
+  add (cs) {
+    const copyLen = math.min(this.blen, cs.byteLength)
+    // copy from right to left until max is reached
+    for (let i = 0; i < copyLen; i++) {
+      this.bs[(this.bpos + this.blen - i - 1) % this.blen] ^= cs[cs.byteLength - i - 1]
+    }
+  }
+
+  /**
+   * @param {number} byte
+   */
+  write (byte) {
+    // [0,m1,m2,b]
+    //  x            <- bpos
+    // Shift one byte to the left, add b
+    this.bs[this.bpos] = byte
+    this.bpos = (this.bpos + 1) % this.blen
+    // mod
+    for (let i = 7; i >= 0; i--) {
+      if (((this.bs[this.bpos] >>> i) & 1) === 1) {
+        this.add(buffer.shiftNBitsLeft(this.m, i))
+      }
+    }
+    // if (this.bs[this.bpos] !== 0) { error.unexpectedCase() }
+    // assert(this.bs[this.bpos] === 0)
+  }
+
+  getFingerprint () {
+    const result = new Uint8Array(this.blen - 1)
+    for (let i = 0; i < result.byteLength; i++) {
+      result[i] = this.bs[(this.bpos + i + 1) % this.blen]
+    }
+    return result
+  }
+}

package/hash/rabin.d.ts

@@ -0,0 +1,27 @@
+export const StandardIrreducible8: Uint8Array;
+export const StandardIrreducible16: Uint8Array;
+export const StandardIrreducible32: Uint8Array;
+export const StandardIrreducible64: Uint8Array;
+export const StandardIrreducible128: Uint8Array;
+export class RabinEncoder {
+    /**
+     * @param {Uint8Array} m assert(m[0] === 1)
+     */
+    constructor(m: Uint8Array);
+    m: Uint8Array;
+    blen: number;
+    bs: Uint8Array;
+    cache: Uint8Array;
+    /**
+     * This describes the position of the most significant byte (starts with 0 and increases with
+     * shift)
+     */
+    bpos: number;
+    /**
+     * @param {number} byte
+     */
+    write(byte: number): void;
+    getFingerprint(): Uint8Array;
+}
+export function fingerprint(irreducible: Uint8Array, data: Uint8Array): Uint8Array;
+//# sourceMappingURL=rabin.d.ts.map

package/hash/rabin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rabin.d.ts","sourceRoot":"","sources":["rabin.js"],"names":[],"mappings":"AAUA,8CAA4D;AAC5D,+CAAkE;AAClE,+CAA4E;AAC5E,+CAA+F;AAC/F,gDAAmI;AAmCnI;IACE;;OAEG;IACH,eAFW,UAAU,EAYpB;IATC,cAAU;IACV,aAAwB;IACxB,eAAmC;IACnC,kBAA2B;IAC3B;;;OAGG;IACH,aAAa;IAGf;;OAEG;IACH,YAFW,MAAM,QAYhB;IAED,6BAMC;CACF;AAMM,yCAHI,UAAU,QACV,UAAU,cAQpB"}

package/hash/rabin.js

@@ -0,0 +1,100 @@
+/**
+ * @module rabin
+ *
+ * Very efficient & versatile fingerprint/hashing algorithm. However, it is not cryptographically
+ * secure. Well suited for fingerprinting.
+ */
+
+import * as buffer from '../buffer.js'
+import * as map from '../map.js'
+
+export const StandardIrreducible8 = new Uint8Array([1, 221])
+export const StandardIrreducible16 = new Uint8Array([1, 244, 157])
+export const StandardIrreducible32 = new Uint8Array([1, 149, 183, 205, 191])
+export const StandardIrreducible64 = new Uint8Array([1, 133, 250, 114, 193, 250, 28, 193, 231])
+export const StandardIrreducible128 = new Uint8Array([1, 94, 109, 166, 228, 6, 222, 102, 239, 27, 128, 184, 13, 50, 112, 169, 199])
+
+/**
+ * Maps from a modulo to the precomputed values.
+ *
+ * @type {Map<string,Uint8Array>}
+ */
+const _precomputedFingerprintCache = new Map()
+
+/**
+ * @param {Uint8Array} m
+ */
+const ensureCache = m => map.setIfUndefined(_precomputedFingerprintCache, buffer.toBase64(m), () => {
+  const byteLen = m.byteLength
+  const cache = new Uint8Array(256 * byteLen)
+  // Use dynamic computing to compute the cached results.
+  // Starting values: cache(0) = 0; cache(1) = m
+  cache.set(m, byteLen)
+  for (let bit = 1; bit < 8; bit++) {
+    const mBitShifted = buffer.shiftNBitsLeft(m, bit)
+    const bitShifted = 1 << bit
+    for (let j = 0; j < bitShifted; j++) {
+      // apply the shifted result (reducing the degree of the polynomial)
+      const msb = bitShifted | j
+      const rest = msb ^ mBitShifted[0]
+      for (let i = 0; i < byteLen; i++) {
+        // rest is already precomputed in the cache
+        cache[msb * byteLen + i] = cache[rest * byteLen + i] ^ mBitShifted[i]
+      }
+      // if (cache[(bitShifted | j) * byteLen] !== (bitShifted | j)) { error.unexpectedCase() }
+    }
+  }
+  return cache
+})
+
+export class RabinEncoder {
+  /**
+   * @param {Uint8Array} m assert(m[0] === 1)
+   */
+  constructor (m) {
+    this.m = m
+    this.blen = m.byteLength
+    this.bs = new Uint8Array(this.blen)
+    this.cache = ensureCache(m)
+    /**
+     * This describes the position of the most significant byte (starts with 0 and increases with
+     * shift)
+     */
+    this.bpos = 0
+  }
+
+  /**
+   * @param {number} byte
+   */
+  write (byte) {
+    // assert(this.bs[0] === 0)
+    // Shift one byte to the left, add b
+    this.bs[this.bpos] = byte
+    this.bpos = (this.bpos + 1) % this.blen
+    const msb = this.bs[this.bpos]
+    for (let i = 0; i < this.blen; i++) {
+      this.bs[(this.bpos + i) % this.blen] ^= this.cache[msb * this.blen + i]
+    }
+    // assert(this.bs[this.bpos] === 0)
+  }
+
+  getFingerprint () {
+    const result = new Uint8Array(this.blen - 1)
+    for (let i = 0; i < result.byteLength; i++) {
+      result[i] = this.bs[(this.bpos + i + 1) % this.blen]
+    }
+    return result
+  }
+}
+
+/**
+ * @param {Uint8Array} irreducible
+ * @param {Uint8Array} data
+ */
+export const fingerprint = (irreducible, data) => {
+  const encoder = new RabinEncoder(irreducible)
+  for (let i = 0; i < data.length; i++) {
+    encoder.write(data[i])
+  }
+  return encoder.getFingerprint()
+}

package/hash/rabin.test.d.ts

@@ -0,0 +1,8 @@
+export function testPolynomialBasics(_tc: t.TestCase): void;
+export function testIrreducibleInput(_tc: t.TestCase): void;
+export function testIrreducibleSpread(_tc: t.TestCase): void;
+export function testGenerateIrreducibles(_tc: t.TestCase): void;
+export function testFingerprintCompatiblity(tc: t.TestCase): void;
+export function testConflicts(tc: t.TestCase): void;
+import * as t from '../testing.js';
+//# sourceMappingURL=rabin.test.d.ts.map

package/hash/rabin.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rabin.test.d.ts","sourceRoot":"","sources":["rabin.test.js"],"names":[],"mappings":"AAaO,0CAFI,EAAE,QAAQ,QASpB;AAKM,0CAFI,EAAE,QAAQ,QAapB;AAKM,2CAFI,EAAE,QAAQ,QASpB;AAwBM,8CAFI,EAAE,QAAQ,QAyBpB;AAmGM,gDAFI,EAAE,QAAQ,QAQpB;AAKM,kCAFI,EAAE,QAAQ,QA4BpB;mBAvOkB,eAAe"}

package/hash/sha256.fallback.d.ts

@@ -0,0 +1,2 @@
+export function digest(data: Uint8Array): Uint8Array;
+//# sourceMappingURL=sha256.fallback.d.ts.map

package/hash/sha256.fallback.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sha256.fallback.d.ts","sourceRoot":"","sources":["sha256.fallback.js"],"names":[],"mappings":"AA2KO,6BAFI,UAAU,cAEkC"}