react-native-quick-crypto 1.1.0 → 1.1.1

package/deps/simdutf/scripts/base64/avx512.py

@@ -1,76 +0,0 @@
-lookup_0 = [0 for i in range(64)]
-lookup_1 = [0 for i in range(64)]
-for i in range(64):
-    lookup_0[i] = 0x80
-    lookup_1[i] = 0x80
-lookup = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
-for i in range(64):
-    val = ord(lookup[i])
-    bit6 = val & 0x40
-    bits05 = val & 0x3f
-    if bit6:
-        lookup_1[bits05] = i
-    else:
-        lookup_0[bits05] = i
-allowed = "\t\r\n "
-for z in allowed:
-    lookup_0[ord(z)] = 0xff
-def sign8(x):
-    if x >= 128:
-        return x - 256
-    return x
-lookup_0.reverse()
-lookup_1.reverse()
-print("lookup0:")
-print(", ".join([str(sign8(i)) for i in lookup_0]))
-print("lookup1:")
-print(", ".join([str(sign8(i)) for i in lookup_1]))
-lookupn = [0 for i in range(64)]
-output = 0
-for ifrom in range(16):
-    lookupn[ifrom*4 + 0] = output + 3
-    lookupn[ifrom*4 + 1] = output + 2
-    lookupn[ifrom*4 + 2] = output + 1
-    lookupn[ifrom*4 + 3] = output + 0
-    output += 4
-lookupn.reverse()
-print("reverse:")
-print(", ".join([str(i) for i in lookupn]))
-
-print("====")
-
-lookup_0 = [0 for i in range(64)]
-lookup_1 = [0 for i in range(64)]
-for i in range(64):
-    lookup_0[i] = 0x80
-    lookup_1[i] = 0x80
-lookup = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"
-for i in range(64):
-    val = ord(lookup[i])
-    bit6 = val & 0x40
-    bits05 = val & 0x3f
-    if bit6:
-        lookup_1[bits05] = i
-    else:
-        lookup_0[bits05] = i
-allowed = "\0\t\r\n "
-for z in allowed:
-    lookup_0[ord(z)] = 0xff
-
-lookup_0.reverse()
-lookup_1.reverse()
-print("lookup0:")
-print(", ".join([str(sign8(i)) for i in lookup_0]))
-print("lookup1:")
-print(", ".join([str(sign8(i)) for i in lookup_1]))
-lookupn = [0 for i in range(64)]
-output = 0
-for ifrom in range(16):
-    lookupn[ifrom*4 + 0] = output + 3
-    lookupn[ifrom*4 + 1] = output + 2
-    lookupn[ifrom*4 + 2] = output + 1
-    lookupn[ifrom*4 + 3] = output + 0
-    output += 4
-lookupn.reverse()
-print("reverse:")
-print(", ".join([str(i) for i in lookupn]))

package/deps/simdutf/scripts/base64/neon_decode.py

@@ -1,143 +0,0 @@
-t='ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
-spaces=' \t\n\r\f'
-lut_lo = [0x3a, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x61, 0xe1, 0xb4, 0xe5, 0xe5, 0xf4, 0xb4]
-lut_hi = [0x11, 0x20, 0x42, 0x80, 0x8,  0x4,  0x8,  0x4, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20]
-roll = [0x0, 0x10, 0x13, 0x4, 0xbf, 0xbf, 0xb9, 0xb9, 0x0, 0x0,  0x0,  0x0, 0x0,  0x0,  0x0,  0x0]
-def decode(s):
-    low = s & 0xf
-    high = s >> 4
-    m = lut_lo[low] & lut_hi[high]
-    if(m > 0x3):
-        return (m, None)
-    if s == 0x2f:
-        off = roll[high - 1]
-    else:
-        off = roll[high]
-    return (m,(s + off)&0xff)
-
-
-for i in range(256):
-    m,d = decode(i)
-    if d is None:
-        assert t.find(chr(i)) == -1
-        assert spaces.find(chr(i)) == -1
-        continue
-    if m == 0:
-        assert d >= 0
-        # we must have a base64 element
-        v = t.find(chr(i))
-        assert v == d
-    else:
-        # we must have a space
-        v = spaces.find(chr(i))
-        assert v >= 0, (i, chr(i), v)
-print("REGULAR")
-print("lut_lo")
-print(",".join([hex(c) for c in lut_lo]))
-print("lut_hi")
-print(",".join([hex(c) for c in lut_hi]))
-print("roll")
-print(",".join([hex(c) for c in roll]))
-
-
-print("SWITCHING TO BASE64URL")
-print()
-t='ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_'
-spaces=' \t\n\r\f'
-
-lut_lo = [0x3a, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x61, 0xe1, 0xb4, 0xf4, 0xe5, 0xf4, 0xb0]
-lut_hi = [0x11, 0x20, 0x42, 0x80, 0x8,  0x4,  0x8,  0x4, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20]
-roll = [0xe0, 0x11, 0x13, 0x4, 0xbf, 0xbf, 0xb9, 0xb9, 0x0, 0x0,  0x0,  0x0, 0x0,  0x0,  0x0,  0x0]
-t='ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_'
-spaces=' \t\n\r\f' ## ['0x20', '0x9', '0xa', '0xd']
-
-
-lut_lo = [0x0 for i in range(16)]
-lut_hi = [0x0 for i in range(16)]
-#roll = [0 for i in range(16)]
-
-#0x00 are forbidden except for \t \n \r \f which go to one
-lut_hi[0] = 0x11
-for z in range(16):
-    if '\t\n\r\f'.find(chr(z)) != -1:
-        lut_lo[z & 0xf] = 0x1 # allowed
-    else:
-        lut_lo[z] = 0x10 # forbidden
-#0x10 and 0x80 all forbidden
-lut_hi[0x1] = 0x20
-for z in range(0x8, 16):
-    lut_hi[z] = 0x20
-#lut_hi[0x8] = 0x20
-
-for z in range(16):
-    lut_lo[z] |= 0x20
-
-#0x20 selective
-lut_hi[0x2] = 0x42
-for z in range(16):
-    if z == 0:
-        lut_lo[z] |= 0x2
-    elif z != 0xd:
-        lut_lo[z] |= 0x40
-
-
-#0x30 numbers
-lut_hi[0x3] = 0x80
-for z in range(10,16):
-    lut_lo[z] |= 0x80
-
-#0x40, 0x60 letters
-lut_hi[0x4] = 0x8
-lut_hi[0x6] = 0x8
-lut_lo[0] |= 0x8
-
-#0x7 letters
-#0x5 letters
-lut_hi[0x5] |= 0x4
-lut_hi[0x7] |= 0x4
-for i in range(0xb,16):
-    lut_lo[i] |= 0x4
-
-
-
-def decodes(s):
-    low = s & 0xf
-    high = s >> 4
-    m = lut_lo[low] & lut_hi[high]
-    is_underscore = s == 0x5f
-    if(is_underscore):
-        m = 0
-        high = 0
-    if(m > 0x3):
-        return (m, None)
-    if s == 0x2d:
-        off = roll[high - 1]
-    else:
-        off = roll[high]
-    return (m,(s + off)&0xff)
-print("lut_lo")
-print(",".join([hex(c) for c in lut_lo]))
-print("lut_hi")
-print(",".join([hex(c) for c in lut_hi]))
-print("roll")
-print(",".join([hex(c) for c in roll]))
-
-
-for i in range(256):
-    m,d = decodes(i)
-    if d is None:
-        assert t.find(chr(i)) == -1
-        assert spaces.find(chr(i)) == -1
-        continue
-    if m == 0:
-        assert d >= 0
-        # we must have a base64 element
-        v = t.find(chr(i))
-        if(v != d): 
-            print(hex(i), chr(i), v, d)
-        #assert v == d
-    else:
-        # we must have a space
-        v = spaces.find(chr(i))
-        assert v >= 0, (i, chr(i), v)
-

package/deps/simdutf/scripts/base64/neon_generate_lut.py

@@ -1,101 +0,0 @@
-lut_lo = [0x0 for _ in range(16)]
-lut_hi = [0x0 for _ in range(16)]
-
-# uses (c & 0xf) for indexing lut_lo
-# uses ((c >> 3) & 0xf) for indexing lut_hi
-# bytes with c > 127 will have lut_hi mapped to 0 via vtbl1q_u8
-
-# represent spaces by 0x1
-# represent + (_) by 0x2
-# represent / (-) by 0x4
-# represent numbers by 0x8
-# represent the partial row of upper alphabets with 0x10
-# represent full valid row of upper alphabets with 0x20
-# represent the partial row of lower alphabets with 0x40
-# represent full valid row of lower alphabets with 0x80
-# since '@' and 'P' both map to same lut_lo[0], use two different bits to separate them
-lut_hi[0] = 0x0  # ['\x00', '\x01', '\x02', '\x03', '\x04', '\x05', '\x06', '\x07']
-lut_hi[1] = (
-    0x1  # can have spaces ['\x08', '\t', '\n', '\x0b', '\x0c', '\r', '\x0e', '\x0f']
-)
-for z in range(16):
-    if "\t\n\r\f".find(chr(z)) != -1:
-        lut_lo[z & 0xF] = 0x1  # allowed
-
-# invalid chars
-lut_hi[2] = 0x0  # ['\x10', '\x11', '\x12', '\x13', '\x14', '\x15', '\x16', '\x17']
-lut_hi[3] = 0x0  # ['\x18', '\x19', '\x1a', '\x1b', '\x1c', '\x1d', '\x1e', '\x1f']
-
-lut_hi[4] = 0x1  # can have spaces [' ', '!', '"', '#', '$', '%', '&', "'"]
-lut_lo[ord(" ") & 0xF] |= 0x1
-
-lut_hi[5] = 0x6  # for + and / ['(', ')', '*', '+', ',', '-', '.', '/']
-
-lut_lo[ord("+") & 0xF] |= 0x2
-lut_lo[ord("/") & 0xF] |= 0x4
-
-# 0x30 numbers
-lut_hi[0x6] = 0x8  # ['0', '1', '2', '3', '4', '5', '6', '7']
-lut_hi[0x7] = 0x8  # ['8', '9', ':', ';', '<', '=', '>', '?']
-for z in range(0, 10):
-    lut_lo[z] |= 0x8
-
-# 0x40, 0x60 letters
-lut_hi[0x8] = 0x10  # ['@', 'A', 'B', 'C', 'D', 'E', 'F', 'G']
-lut_hi[0x9] = 0x20  # ['H', 'I', 'J', 'K', 'L', 'M', 'N', 'O']
-lut_hi[10] = 0x20  # ['P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W']
-lut_hi[11] = 0x10  # ['X', 'Y', 'Z', '[', '\\', ']', '^', '_']
-
-lut_lo[ord("A") & 0xF] |= 0x10
-lut_lo[ord("B") & 0xF] |= 0x10
-lut_lo[ord("C") & 0xF] |= 0x10
-lut_lo[ord("D") & 0xF] |= 0x10
-lut_lo[ord("E") & 0xF] |= 0x10
-lut_lo[ord("F") & 0xF] |= 0x10
-lut_lo[ord("G") & 0xF] |= 0x10
-lut_lo[ord("X") & 0xF] |= 0x10
-lut_lo[ord("Y") & 0xF] |= 0x10
-lut_lo[ord("Z") & 0xF] |= 0x10
-
-lut_hi[12] = 0x40  # ['`', 'a', 'b', 'c', 'd', 'e', 'f', 'g']
-lut_hi[13] = 0x80  # ['h', 'i', 'j', 'k', 'l', 'm', 'n', 'o']
-lut_hi[14] = 0x80  # ['p', 'q', 'r', 's', 't', 'u', 'v', 'w']
-lut_hi[15] = 0x40  # ['x', 'y', 'z', '{', '|', '}', '~', '\x7f']
-
-lut_lo[ord("a") & 0xF] |= 0x40
-lut_lo[ord("b") & 0xF] |= 0x40
-lut_lo[ord("c") & 0xF] |= 0x40
-lut_lo[ord("d") & 0xF] |= 0x40
-lut_lo[ord("e") & 0xF] |= 0x40
-lut_lo[ord("f") & 0xF] |= 0x40
-lut_lo[ord("g") & 0xF] |= 0x40
-lut_lo[ord("x") & 0xF] |= 0x40
-lut_lo[ord("y") & 0xF] |= 0x40
-lut_lo[ord("z") & 0xF] |= 0x40
-
-for z in range(0, 16):
-    lut_lo[z] |= 0x80 | 0x20
-
-print("base64 regular lut_lo")
-print(",".join([hex(c) for c in lut_lo]))
-print("base64 regular lut_hi")
-print(",".join([hex(c) for c in lut_hi]))
-
-lut_lo[ord("-") & 0xF] |= 0x4
-lut_lo[ord("+") & 0xF] &= ~0x2
-lut_lo[ord("/") & 0xF] &= ~0x4
-lut_lo[ord("_") & 0xF] |= 0x2
-lut_hi[11] = 0x12  # can have _ as well ['X', 'Y', 'Z', '[', '\\', ']', '^', '_']
-lut_hi[5] = 0x4  # for - ['(', ')', '*', '+', ',', '-', '.', '/']
-print("base64 url lut_lo")
-print(",".join([hex(c) for c in lut_lo]))
-print("base64 url lut_hi")
-print(",".join([hex(c) for c in lut_hi]))
-
-lut_lo[ord("+") & 0xF] |= 0x2
-lut_lo[ord("/") & 0xF] |= 0x4
-lut_hi[5] = 0x6  # for +, - and / ['(', ')', '*', '+', ',', '-', '.', '/']
-print("base64 hybrid lut_lo")
-print(",".join([hex(c) for c in lut_lo]))
-print("base64 hybrid lut_hi")
-print(",".join([hex(c) for c in lut_hi]))

package/deps/simdutf/scripts/base64/sse.py

@@ -1,252 +0,0 @@
-import sys
-delta_asso = [0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00,0x00, 0x00, 0x00, 0x0F, 0x00, 0x0F]
-check_asso = [0x0D, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x03, 0x07, 0x0B, 0x0B, 0x0B, 0x0F]
-
-delta_values =[(0x00), (0x00), (0x00), (0x13), (0x04), (0xBF), (0xBF), (0xB9), (0xB9), (0x00), (0x10), (0xC3), (0xBF), (0xBF), (0xB9), (0xB9)]
-check_values = [(0x80), (0x80), (0x80), (0x80), (0xCF), (0xBF), (0xD5), (0xA6), (0xB5), (0x86), (0xD1), (0x80), (0xB1), (0x80), (0x91), (0x80)]
-
-
-valid = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
-
-def safechr(i):
-    if i < 32:
-        return '.'
-    if i > 127:
-        return '?'
-    return chr(i)
-
-def safehex(x):
-    return "0x{0:2x}".format(x)
-
-def to_signed(x):
-    if(x >= 128):
-        return x - 256
-    return x
-
-def to_unsigned(x):
-    if(x < 0):
-        return x + 256
-    return x
-
-def sat(x, y):
-    x = to_signed(x)
-    y = to_signed(y)
-    z = x + y
-    if(z > 127):
-        return 127
-    if(z < -128):
-        return to_unsigned(-128)
-    return to_unsigned(z)
-
-def lookup(table, index):
-    print("looking up ", hex(index))
-    if(index >= 128):
-        return 0
-    return table[index&0xf]
-
-
-
-def quietlookup(table, index):
-    if(index >= 128):
-        return 0
-    return table[index&0xf]
-
-def process(src):
-    shifted = (src >> 3)%256
-    delta_hash = (lookup(delta_asso,src) + shifted + 1) >> 1
-    check_hash = (lookup(check_asso,src) + shifted + 1) >> 1
-    out = sat(lookup(delta_values,delta_hash), src)
-    chk = sat(lookup(check_values,check_hash), src)
-    mask = chk & 0x80
-    return (out, mask)
-
-def processquiet(src):
-    shifted = (src >> 3)%256
-    delta_hash = (quietlookup(delta_asso,src) + shifted + 1) >> 1
-    check_hash = (quietlookup(check_asso,src) + shifted + 1) >> 1
-    out = sat(quietlookup(delta_values,delta_hash), src)
-    chk = sat(quietlookup(check_values,check_hash), src)
-    mask = chk & 0x80
-    return (out, mask)
-
-def is_ok(i):
-    out, mask = processquiet(i)
-    if mask == 0:
-        return 1
-    return 0
-
-def computestring():
-    s = ""
-    for i in range(256):
-        out, mask = processquiet(i)
-        if(mask == 0):
-            s +=  safechr(i)
-    return s
-print(computestring() + " " + str(len(computestring())))
-
-def print_layout():
-    t={}
-    for i in range(256):
-        src = i
-        shifted = (src >> 3)%256
-        check_hash = (quietlookup(check_asso,src) + shifted + 1) >> 1
-        if check_hash not in t:
-            t[check_hash] = []
-        t[check_hash].append(i)
-    for check_hash in range(16):
-        if check_hash in t:
-            off = quietlookup(check_values,check_hash)
-            print(hex(check_hash), hex(off), end="")
-            print("\t", " ".join(["   "+safechr(c) for c in t[check_hash]]))
-        else:
-            continue
-
-
-def is_valid():
-    t={}
-    for i in range(256):
-        src = i
-        shifted = (src >> 3)%256
-        check_hash = (quietlookup(check_asso,src) + shifted + 1) >> 1
-        if check_hash not in t:
-            t[check_hash] = []
-        t[check_hash].append(i)
-    for check_hash in t.keys():
-        if check_hash in t:
-            array = t[check_hash]
-            i = 0
-            while i < len(array) and valid.find(chr(array[i])) == -1:
-                i += 1
-            while i < len(array) and valid.find(chr(array[i])) != -1:
-                i += 1
-            while i < len(array) and array[i] >= 128:
-                i += 1
-            if i < len(array):
-                return False
-        else:
-            continue
-    return True
-
-print_layout()
-print(is_valid())
-
-valid = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"
-print("----")
-def fun_adjust():
-    for zz in range(256):
-        check_asso[ord('-')&0xf] = zz
-        for yy in range(256):
-            check_asso[ord('_')&0xf] = yy
-            if(is_valid()):
-                print("----")
-                print_layout()
-                print(is_valid())
-                print("found")
-                return
-fun_adjust()
-            #sys.exit(0)
-
-def adjust(array, start, end, check_hash):
-    for j in range(256):
-        is_ok = True
-        for i in range(len(array)):
-            valid = (sat(j,array[i])&0x80 == 0) # sat(quietlookup(check_values,check_hash), src)
-            should_be_valid = (i>=start and i < end)
-            is_ok = is_ok and (valid == should_be_valid)
-        if(is_ok):
-            check_values[check_hash&0xf] = j
-            return
-    raise "unexpected"
-
-
-    chk = sat(quietlookup(check_values,check_hash), src)
-    mask = chk & 0x80
-
-def process_explicit():
-    t={}
-    for i in range(256):
-        src = i
-        shifted = (src >> 3)%256
-        check_hash = (quietlookup(check_asso,src) + shifted + 1) >> 1
-        if check_hash not in t:
-            t[check_hash] = []
-        t[check_hash].append(i)
-    for check_hash in t.keys():
-        if check_hash in t:
-            array = t[check_hash]
-            i = 0
-            while i < len(array) and valid.find(chr(array[i])) == -1:
-                i += 1
-            if i < len(array) and valid.find(chr(array[i])) != -1:
-                start = i
-                while i < len(array) and valid.find(chr(array[i])) != -1:
-                    i += 1
-                end = i
-                adjust(array, start, end, check_hash)
-        else:
-            continue
-    return True
-print("process")
-process_explicit()
-print("string")
-print(computestring()+ " "+str(len(computestring())))
-
-for c in valid:
-    print(c,processquiet(ord(c)))
-
-def examine():
-    t={}
-    for i in valid:
-        src = ord(i)
-        shifted = (src >> 3)%256
-        check_hash = (quietlookup(delta_asso,src) + shifted + 1) >> 1
-        if check_hash not in t:
-            t[check_hash] = []
-        t[check_hash].append(i)
-    for check_hash in t.keys():
-        print(check_hash, t[check_hash])
-    return True
-examine()
-
-delta_values[10] += 1 
-
-delta_values[13] += 33 
-
-for c in valid:
-    print(c,processquiet(ord(c)))
-
-
-
-def casthex(v):
-    if(v >= 0x80):
-        return "uint8_t("+"0x{:X}".format(v)+")"
-    return "0x{:X}".format(v)
-def printme(c):
-    print(",".join([casthex(i) for i in c]))
-print("delta_asso")
-printme(delta_asso)
-print("check_asso")
-printme(check_asso)
-print("delta_values")
-printme(delta_values)
-print("check_values")
-printme(check_values)
-
-def processverbose(src):
-    print("processing ", hex(src))
-    shifted = (src >> 3)%256
-    print("shifted ", hex(shifted))
-    delta_hash = (lookup(delta_asso,src) + shifted + 1) >> 1
-    print("delta_hash ", hex(delta_hash))
-    check_hash = (lookup(check_asso,src) + shifted + 1) >> 1
-    print("check_hash ", hex(check_hash))
-    out = sat(lookup(delta_values,delta_hash), src)
-    print("out ", hex(out))
-    chk = sat(lookup(check_values,check_hash), src)
-    print("chk ", hex(chk))
-
-    mask = chk & 0x80
-    return (out, mask)
-processverbose(ord('-'))
-
-print(computestring()+ " "+str(len(computestring())))