visaljs 0.0.2 → 0.0.4

package/runtime/third_party/boringssl/third_party/fiat/p256_field.c.inc

@@ -0,0 +1,26 @@
+#include <openssl/base.h>
+#include "bedrock_unverified_platform.c.inc"
+
+#if defined(BORINGSSL_HAS_UINT128)
+#include "p256_64.h"
+#elif defined(OPENSSL_64_BIT)
+#include "p256_64_msvc.h"
+#else
+#include "p256_field_32.br.c.inc"
+#include "p256_32.h"
+// the 32-bit Bedrock-generated field halving calls Fiat-C code for add, sub
+static inline void p256_coord_add(br_word_t out, br_word_t x, br_word_t y) {
+  fiat_p256_add((uint32_t*)out, (const uint32_t*)x, (const uint32_t*)y);
+}
+static inline void p256_coord_sub(br_word_t out, br_word_t x, br_word_t y) {
+  fiat_p256_sub((uint32_t*)out, (const uint32_t*)x, (const uint32_t*)y);
+}
+#endif
+
+// the Bedrock-generated point operations call Fiat-C or Fiat-x86 mul, sqr
+static inline void p256_coord_mul(br_word_t out, br_word_t x, br_word_t y) {
+  fiat_p256_mul((br_word_t*)out, (const br_word_t*)x, (const br_word_t*)y);
+}
+static inline void p256_coord_sqr(br_word_t out, br_word_t x) {
+  fiat_p256_square((br_word_t*)out, (const br_word_t*)x);
+}

package/runtime/third_party/boringssl/third_party/fiat/p256_field_32.br.c.inc

@@ -0,0 +1,71 @@
+// Generated from Bedrock code in Fiat Cryptography. Avoid editing directly.
+
+static inline br_word_t shrd(br_word_t lo, br_word_t hi, br_word_t n) {
+  br_word_t res;
+  res = lo>>(n&(sizeof(br_word_t)*8-1));
+  if (n) {
+    res = (hi<<((((((0u-(br_word_t)1)>>27)&63)+1)-n)&(sizeof(br_word_t)*8-1)))|res;
+  } else {
+    /*skip*/
+  }
+  return res;
+}
+
+static inline br_word_t p256_coord_nonzero(br_word_t p_x) {
+  br_word_t nz;
+  nz = (((_br_load(p_x))|(_br_load(p_x+4)))|(_br_load((p_x+4)+4)))|(_br_load(((p_x+4)+4)+4));
+  nz = nz|(_br_load((((p_x+4)+4)+4)+4));
+  nz = nz|(_br_load(((((p_x+4)+4)+4)+4)+4));
+  nz = nz|(_br_load((((((p_x+4)+4)+4)+4)+4)+4));
+  nz = nz|(_br_load(((((((p_x+4)+4)+4)+4)+4)+4)+4));
+  nz = br_broadcast_nonzero(nz);
+  return nz;
+}
+
+static inline void u256_shr(br_word_t p_out, br_word_t p_x, br_word_t n) {
+  br_word_t x0, x1, x2, x3, x4, x5, x6, x7, y0, y1, y2, y3, y4, y5, y6, y7;
+  x0 = _br_load(p_x);
+  x1 = _br_load(p_x+4);
+  x2 = _br_load((p_x+4)+4);
+  x3 = _br_load(((p_x+4)+4)+4);
+  x4 = _br_load((((p_x+4)+4)+4)+4);
+  x5 = _br_load(((((p_x+4)+4)+4)+4)+4);
+  x6 = _br_load((((((p_x+4)+4)+4)+4)+4)+4);
+  x7 = _br_load(((((((p_x+4)+4)+4)+4)+4)+4)+4);
+  y0 = shrd(x0, x1, n);
+  y1 = shrd(x1, x2, n);
+  y2 = shrd(x2, x3, n);
+  y3 = shrd(x3, x4, n);
+  y4 = shrd(x4, x5, n);
+  y5 = shrd(x5, x6, n);
+  y6 = shrd(x6, x7, n);
+  y7 = x7>>(n&(sizeof(br_word_t)*8-1));
+  _br_store(p_out, y0);
+  _br_store(p_out+4, y1);
+  _br_store((p_out+4)+4, y2);
+  _br_store(((p_out+4)+4)+4, y3);
+  _br_store((((p_out+4)+4)+4)+4, y4);
+  _br_store(((((p_out+4)+4)+4)+4)+4, y5);
+  _br_store((((((p_out+4)+4)+4)+4)+4)+4, y6);
+  _br_store(((((((p_out+4)+4)+4)+4)+4)+4)+4, y7);
+}
+
+static inline void u256_set_p256_minushalf_conditional(br_word_t p_out, br_word_t mask) {
+  br_word_t mh0, mh1, mh2, mh3, mh4, mh5, mh6, mh7;
+  mh0 = 0u-(br_word_t)1;
+  mh1 = mh0;
+  mh2 = mh0>>1;
+  mh3 = (br_word_t)0;
+  mh4 = (br_word_t)0;
+  mh5 = (br_word_t)1<<31;
+  mh6 = mh5;
+  mh7 = mh2;
+  _br_store(p_out, mask&mh0);
+  _br_store(p_out+4, mask&mh1);
+  _br_store((p_out+4)+4, mask&mh2);
+  _br_store(((p_out+4)+4)+4, mask&mh3);
+  _br_store((((p_out+4)+4)+4)+4, mask&mh4);
+  _br_store(((((p_out+4)+4)+4)+4)+4, mask&mh5);
+  _br_store((((((p_out+4)+4)+4)+4)+4)+4, mask&mh6);
+  _br_store(((((((p_out+4)+4)+4)+4)+4)+4)+4, mask&mh7);
+}

package/runtime/third_party/boringssl/third_party/fiat/p256_field_64.br.c.inc

@@ -0,0 +1,84 @@
+// Generated from Bedrock code in Fiat Cryptography. Avoid editing directly.
+
+static inline br_word_t shrd(br_word_t lo, br_word_t hi, br_word_t n) {
+  br_word_t res;
+  res = lo>>(n&(sizeof(br_word_t)*8-1));
+  if (n) {
+    res = (hi<<((((((0u-(br_word_t)1)>>27)&63)+1)-n)&(sizeof(br_word_t)*8-1)))|res;
+  } else {
+    /*skip*/
+  }
+  return res;
+}
+
+static inline void p256_coord_add(br_word_t p_out, br_word_t p_x, br_word_t p_y) {
+  br_word_t r4, carry, t0, t1, t2, borrow, t3, r0, r1, r2, r3;
+  carry = br_full_add(_br_load(p_x), _br_load(p_y), (br_word_t)0, &t0);
+  carry = br_full_add(_br_load(p_x+8), _br_load(p_y+8), carry, &t1);
+  carry = br_full_add(_br_load((p_x+8)+8), _br_load((p_y+8)+8), carry, &t2);
+  carry = br_full_add(_br_load(((p_x+8)+8)+8), _br_load(((p_y+8)+8)+8), carry, &t3);
+  borrow = br_full_sub(t0, (br_word_t)0xffffffffffffffff, (br_word_t)0, &r0);
+  borrow = br_full_sub(t1, (br_word_t)0xffffffff, borrow, &r1);
+  borrow = br_full_sub(t2, (br_word_t)0, borrow, &r2);
+  borrow = br_full_sub(t3, (br_word_t)0xffffffff00000001, borrow, &r3);
+  borrow = br_full_sub(carry, (br_word_t)0, borrow, &r4);
+  r0 = br_cmov(borrow, t0, r0);
+  r1 = br_cmov(borrow, t1, r1);
+  r2 = br_cmov(borrow, t2, r2);
+  r3 = br_cmov(borrow, t3, r3);
+  _br_store(p_out, r0);
+  _br_store(p_out+8, r1);
+  _br_store((p_out+8)+8, r2);
+  _br_store(((p_out+8)+8)+8, r3);
+}
+
+static inline void p256_coord_sub(br_word_t out, br_word_t x, br_word_t y) {
+  br_word_t borrow, t0, t1, t2, t3, mask, carry, r0, r1, r2, r3;
+  borrow = br_full_sub(_br_load(x), _br_load(y), (br_word_t)0, &t0);
+  borrow = br_full_sub(_br_load(x+8), _br_load(y+8), borrow, &t1);
+  borrow = br_full_sub(_br_load((x+8)+8), _br_load((y+8)+8), borrow, &t2);
+  borrow = br_full_sub(_br_load(((x+8)+8)+8), _br_load(((y+8)+8)+8), borrow, &t3);
+  mask = br_value_barrier(0u-borrow);
+  carry = br_full_add(t0, mask, (br_word_t)0, &r0);
+  carry = br_full_add(t1, mask&0xffffffff, carry, &r1);
+  carry = br_full_add(t2, (br_word_t)0, carry, &r2);
+  carry = br_full_add(t3, mask&0xffffffff00000001, carry, &r3);
+  _br_store(out, r0);
+  _br_store(out+8, r1);
+  _br_store((out+8)+8, r2);
+  _br_store(((out+8)+8)+8, r3);
+}
+
+static inline br_word_t p256_coord_nonzero(br_word_t p_x) {
+  br_word_t nz;
+  nz = br_broadcast_nonzero((((_br_load(p_x))|(_br_load(p_x+8)))|(_br_load((p_x+8)+8)))|(_br_load(((p_x+8)+8)+8)));
+  return nz;
+}
+
+static inline void u256_shr(br_word_t p_out, br_word_t p_x, br_word_t n) {
+  br_word_t x0, x1, x2, x3, y0, y1, y2, y3;
+  x0 = _br_load(p_x);
+  x1 = _br_load(p_x+8);
+  x2 = _br_load((p_x+8)+8);
+  x3 = _br_load(((p_x+8)+8)+8);
+  y0 = shrd(x0, x1, n);
+  y1 = shrd(x1, x2, n);
+  y2 = shrd(x2, x3, n);
+  y3 = x3>>(n&(sizeof(br_word_t)*8-1));
+  _br_store(p_out, y0);
+  _br_store(p_out+8, y1);
+  _br_store((p_out+8)+8, y2);
+  _br_store(((p_out+8)+8)+8, y3);
+}
+
+static inline void u256_set_p256_minushalf_conditional(br_word_t p_out, br_word_t mask) {
+  br_word_t mh0, mh1, mh2, mh3;
+  mh0 = 0u-(br_word_t)1;
+  mh1 = mh0>>((br_word_t)33&(sizeof(br_word_t)*8-1));
+  mh2 = mh0<<((br_word_t)63&(sizeof(br_word_t)*8-1));
+  mh3 = (mh0<<((br_word_t)32&(sizeof(br_word_t)*8-1)))>>1;
+  _br_store(p_out, mask&mh0);
+  _br_store(p_out+8, mask&mh1);
+  _br_store((p_out+8)+8, mask&mh2);
+  _br_store(((p_out+8)+8)+8, mask&mh3);
+}

package/runtime/third_party/boringssl/third_party/fiat/p256_point.br.c.inc

@@ -0,0 +1,112 @@
+// Generated from Bedrock code in Fiat Cryptography. Avoid editing directly.
+
+static inline br_word_t br_broadcast_odd(br_word_t x) {
+  br_word_t y;
+  x = br_value_barrier(x&1);
+  y = 0u-x;
+  return y;
+}
+
+static inline void p256_coord_halve(br_word_t y, br_word_t x) {
+  br_word_t m, mmh;
+  uint8_t _br_stackalloc_mmh[32] = {0}; mmh = (br_word_t)&_br_stackalloc_mmh;
+  m = br_broadcast_odd(_br_load(x));
+  u256_set_p256_minushalf_conditional(mmh, m);
+  u256_shr(y, x, (br_word_t)1);
+  p256_coord_sub(y, y, mmh);
+}
+
+static inline br_word_t p256_point_iszero(br_word_t p_P) {
+  br_word_t z, nz;
+  nz = p256_coord_nonzero((p_P+32)+32);
+  z = ~nz;
+  return z;
+}
+
+static inline void p256_point_double(br_word_t out, br_word_t in1) {
+  br_word_t t2, tmp, A, D;
+  uint8_t _br_stackalloc_D[32] = {0}; D = (br_word_t)&_br_stackalloc_D;
+  uint8_t _br_stackalloc_A[32] = {0}; A = (br_word_t)&_br_stackalloc_A;
+  uint8_t _br_stackalloc_tmp[32] = {0}; tmp = (br_word_t)&_br_stackalloc_tmp;
+  p256_coord_add(D, in1+32, in1+32);
+  p256_coord_sqr(tmp, (in1+32)+32);
+  p256_coord_sqr(D, D);
+  p256_coord_mul((out+32)+32, (in1+32)+32, in1+32);
+  p256_coord_add((out+32)+32, (out+32)+32, (out+32)+32);
+  p256_coord_add(A, in1, tmp);
+  p256_coord_sub(tmp, in1, tmp);
+  uint8_t _br_stackalloc_t2[32] = {0}; t2 = (br_word_t)&_br_stackalloc_t2;
+  p256_coord_add(t2, tmp, tmp);
+  p256_coord_add(tmp, t2, tmp);
+  p256_coord_sqr(out+32, D);
+  p256_coord_mul(A, A, tmp);
+  p256_coord_mul(D, D, in1);
+  p256_coord_sqr(out, A);
+  p256_coord_add(tmp, D, D);
+  p256_coord_sub(out, out, tmp);
+  p256_coord_sub(D, D, out);
+  p256_coord_mul(D, D, A);
+  p256_coord_halve(out+32, out+32);
+  p256_coord_sub(out+32, D, out+32);
+}
+
+static inline br_word_t p256_point_add_nz_nz_neq(br_word_t p_out, br_word_t p_P, br_word_t p_Q) {
+  br_word_t z1z1, z2z2, u1, Hsqr, ok, different_x, different_y, u2, Hcub, s1, r, h, s2;
+  uint8_t _br_stackalloc_z1z1[32] = {0}; z1z1 = (br_word_t)&_br_stackalloc_z1z1;
+  uint8_t _br_stackalloc_z2z2[32] = {0}; z2z2 = (br_word_t)&_br_stackalloc_z2z2;
+  uint8_t _br_stackalloc_u1[32] = {0}; u1 = (br_word_t)&_br_stackalloc_u1;
+  uint8_t _br_stackalloc_u2[32] = {0}; u2 = (br_word_t)&_br_stackalloc_u2;
+  uint8_t _br_stackalloc_h[32] = {0}; h = (br_word_t)&_br_stackalloc_h;
+  uint8_t _br_stackalloc_s1[32] = {0}; s1 = (br_word_t)&_br_stackalloc_s1;
+  uint8_t _br_stackalloc_s2[32] = {0}; s2 = (br_word_t)&_br_stackalloc_s2;
+  uint8_t _br_stackalloc_r[32] = {0}; r = (br_word_t)&_br_stackalloc_r;
+  uint8_t _br_stackalloc_Hsqr[32] = {0}; Hsqr = (br_word_t)&_br_stackalloc_Hsqr;
+  uint8_t _br_stackalloc_Hcub[32] = {0}; Hcub = (br_word_t)&_br_stackalloc_Hcub;
+  p256_coord_sqr(z1z1, (p_P+32)+32);
+  p256_coord_mul(u2, p_Q, z1z1);
+  p256_coord_sqr(z2z2, (p_Q+32)+32);
+  p256_coord_mul(u1, p_P, z2z2);
+  p256_coord_sub(h, u2, u1);
+  p256_coord_mul(s2, (p_P+32)+32, z1z1);
+  p256_coord_mul((p_out+32)+32, h, (p_P+32)+32);
+  p256_coord_mul((p_out+32)+32, (p_out+32)+32, (p_Q+32)+32);
+  p256_coord_mul(s2, s2, p_Q+32);
+  p256_coord_mul(s1, (p_Q+32)+32, z2z2);
+  p256_coord_mul(s1, s1, p_P+32);
+  p256_coord_sub(r, s2, s1);
+  p256_coord_sqr(Hsqr, h);
+  p256_coord_sqr(p_out, r);
+  p256_coord_mul(Hcub, Hsqr, h);
+  p256_coord_mul(u2, u1, Hsqr);
+  different_x = p256_coord_nonzero(Hcub);
+  different_y = p256_coord_nonzero(p_out);
+  ok = br_value_barrier(different_x|different_y);
+  p256_coord_sub(p_out, p_out, Hcub);
+  p256_coord_sub(p_out, p_out, u2);
+  p256_coord_sub(p_out, p_out, u2);
+  p256_coord_sub(h, u2, p_out);
+  p256_coord_mul(s2, Hcub, s1);
+  p256_coord_mul(h, h, r);
+  p256_coord_sub(p_out+32, h, s2);
+  return ok;
+}
+
+static inline void p256_point_add_vartime_if_doubling(br_word_t p_out, br_word_t p_P, br_word_t p_Q) {
+  br_word_t p_tmp, zeroP, zeroQ, ok, p_sel;
+  zeroP = p256_point_iszero(p_P);
+  zeroQ = p256_point_iszero(p_Q);
+  uint8_t _br_stackalloc_p_tmp[96] = {0}; p_tmp = (br_word_t)&_br_stackalloc_p_tmp;
+  ok = p256_point_add_nz_nz_neq(p_tmp, p_P, p_Q);
+  ok = br_declassify((zeroP|zeroQ)|ok);
+  uint8_t _br_stackalloc_p_sel[96] = {0}; p_sel = (br_word_t)&_br_stackalloc_p_sel;
+  br_memset(p_sel, (br_word_t)0, (br_word_t)96);
+  br_memcxor(p_sel, p_tmp, (br_word_t)96, (~zeroP)&(~zeroQ));
+  br_memcxor(p_sel, p_P, (br_word_t)96, (~zeroP)&zeroQ);
+  br_memcxor(p_sel, p_Q, (br_word_t)96, zeroP&(~zeroQ));
+  if (ok) {
+    /*skip*/
+  } else {
+    p256_point_double(p_sel, p_P);
+  }
+  br_memcpy(p_out, p_sel, (br_word_t)96);
+}

package/runtime/third_party/v8-ieee754/README.md

@@ -8,7 +8,8 @@ notice at the top of `ieee754.c`.
   12.4.254.21-node.39). `sin` and `cos` are the fdlibm ones, which is what Node 22 uses.
 - **Converted by `convert.py`** from the upstream file, mechanically: C casts instead of
   `static_cast`, `memcpy` bit casts, the overflow helpers and `numeric_limits` spelled out,
-  `js_ieee754_` names, namespaces dropped, V8's optional libm `sin`/`cos` dropped.
+  `js_ieee754_` names, namespaces dropped, V8's optional libm `sin`/`cos` dropped, and
+  `pow`'s one signed shift past bit 31 done unsigned (UB that UBSan catches).
 - **Checked:** 146,346 inputs (special values, and random ones over 40 orders of magnitude) give
   the same bits as Node for all 21 functions; glibc's libm differs on 6,783 of them.
 

package/runtime/third_party/v8-ieee754/convert.py

@@ -50,6 +50,10 @@ for f in ['cos','sin']:
 k=body.find('#if defined(V8_USE_LIBM_TRIG_FUNCTIONS) && defined(BUILDING_V8_BASE_SHARED)')
 if k>=0:
     e=body.index('#endif',k)+len('#endif'); body=body[:k]+body[e:]
+# pow's odd-integer test shifts a signed int past bit 31 (UB, caught by UBSan): shift it unsigned
+old='if ((j << (52 - k)) == ((int)(ly)))'
+assert old in body
+body=body.replace(old,'if (((int)((uint32_t)j << (52 - k))) == ((int)(ly)))')
 assert 'V8_' not in body.replace('V8_USE','') or True
 hdr='''/* V8's port of fdlibm (src/base/ieee754.cc, V8 12.4, the version Node 22 ships), in C so
  * Math gives Node's results to the last bit (ADR 0014). Changes: C instead of C++ (casts,

package/runtime/third_party/v8-ieee754/ieee754.c

@@ -2711,7 +2711,7 @@ double js_ieee754_pow(double x, double y) {
       k = (iy >> 20) - 0x3ff; /* exponent */
       if (k > 20) {
         j = ly >> (52 - k);
-        if ((j << (52 - k)) == ((int)(ly))) yisint = 2 - (j & 1);
+        if (((int)((uint32_t)j << (52 - k))) == ((int)(ly))) yisint = 2 - (j & 1);
       } else if (ly == 0) {
         j = iy >> (20 - k);
         if ((j << (20 - k)) == iy) yisint = 2 - (j & 1);

package/runtime/third_party/bearssl/LICENSE.txt

@@ -1,21 +0,0 @@
-Copyright (c) 2016 Thomas Pornin <pornin@bolet.org>
-
-Permission is hereby granted, free of charge, to any person obtaining 
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be 
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
-BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
-ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
-CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/runtime/third_party/bearssl/README.txt

@@ -1,136 +0,0 @@
-# Documentation
-
-The most up-to-date documentation is supposed to be available on the
-[BearSSL Web site](https://www.bearssl.org/).
-
-# Disclaimer
-
-BearSSL is considered beta-level software. Most planned functionalities
-are implemented; new evolution may still break both source and binary
-compatibility.
-
-Using BearSSL for production purposes would be a relatively bold but not
-utterly crazy move. BearSSL is free, open-source software, provided
-without any guarantee of fitness or reliability. That being said, it
-appears to behave properly, and only minor issues have been found (and
-fixed) so far. You are encourage to inspect its API and code for
-learning, testing and possibly contributing.
-
-The usage license is explicited in the `LICENSE.txt` file. This is the
-"MIT license". It can be summarised in the following way:
-
- - You can use and reuse the library as you wish, and modify it, and
-   integrate it in your own code, and distribute it as is or in any
-   modified form, and so on.
-
- - The only obligation that the license terms put upon you is that you
-   acknowledge and make it clear that if anything breaks, it is not my
-   fault, and I am not liable for anything, regardless of the type and
-   amount of collateral damage. The license terms say that the copyright
-   notice "shall be included in all copies or substantial portions of
-   the Software": this is how the disclaimer is "made explicit".
-   Basically, I have put it in every source file, so just keep it there.
-
-# Installation
-
-Right now, BearSSL is a simple library, along with a few test and debug
-command-line tools. There is no installer yet. The library _can_ be
-compiled as a shared library on some systems, but since the binary API
-is not fully stabilised, this is not a very good idea to do that right
-now.
-
-To compile the code, just type `make`. This will try to use sane
-"default" values. On a Windows system with Visual Studio, run a console
-with the environment initialised for a specific version of the C compiler,
-and type `nmake`.
-
-To override the default settings, create a custom configuration file in
-the `conf` directory, and invoke `make` (or `nmake`) with an explicit
-`CONF=` parameter. For instance, to use the provided `samd20.mk`
-configuration file (that targets cross-compilation for an Atmel board
-that features a Cortex-M0+ CPU), type:
-
-    make CONF=samd20
-
-The `conf/samd20.mk` file includes the `Unix.mk` file and then overrides
-some of the parameters, including the destination directory. Any custom
-configuration can be made the same way.
-
-Some compile-time options can be set through macros, either on the
-compiler command-line, or in the `src/config.h` file. See the comments
-in that file. Some settings are autodetected but they can still be
-explicitly overridden.
-
-When compilation is done, the library (static and DLL, when appropriate)
-and the command-line tools can be found in the designated build
-directory (by default named `build`). The public headers (to be used
-by applications linked against BearSSL) are in the `inc/` directory.
-
-To run the tests:
-
-  - `testcrypto all` runs the cryptographic tests (test vectors on all
-    implemented cryptogaphic functions). It can be slow. You can also
-    run a selection of the tests by providing their names (run
-    `testcrypto` without any parameter to see the available names).
-
-  - `testspeed all` runs a number of performance benchmarks, there again
-    on cryptographic functions. It gives a taste of how things go on the
-    current platform. As for `testcrypto`, specific named benchmarks can
-    be executed.
-
-  - `testx509` runs X.509 validation tests. The test certificates are
-    all in `test/x509/`.
-
-The `brssl` command-line tool produced in the build directory is a
-stand-alone binary. It can exercise some of the functionalities of
-BearSSL, in particular running a test SSL client or server. It is not
-meant for production purposes (e.g. the SSL client has a mode where it
-disregards the inability to validate the server's certificate, which is
-inherently unsafe, but convenient for debug).
-
-**Using the library** means writing some application code that invokes
-it, and linking with the static library. The header files are all in the
-`inc` directory; copy them wherever makes sense (e.g. in the
-`/usr/local/include` directory). The library itself (`libbearssl.a`) is
-what you link against.
-
-Alternatively, you may want to copy the source files directly into your
-own application code. This will make integrating ulterior versions of
-BearSSL more difficult. If you still want to go down that road, then
-simply copy all the `*.h` and `*.c` files from the `src` and `inc`
-directories into your application source code. In the BearSSL source
-archive, the source files are segregated into various sub-directories,
-but this is for my convenience only. There is no technical requirement
-for that, and all files can be dumped together in a simple directory.
-
-Dependencies are simple and systematic:
-
-  - Each `*.c` file includes `inner.h`
-  - `inner.h` includes `config.h` and `bearssl.h`
-  - `bearssl.h` includes the other `bearssl_*.h`
-
-# Versioning
-
-I follow this simple version numbering scheme:
-
- - Version numbers are `x.y` or `x.y.z` where `x`, `y` and `z` are
-   decimal integers (possibly greater than 10). When the `.z` part is
-   missing, it is equivalent to `.0`.
-
- - Backward compatibility is maintained, at both source and binary levels,
-   for each major version: this means that if some application code was
-   designed for version `x.y`, then it should compile, link and run
-   properly with any version `x.y'` for any `y'` greater than `y`.
-
-   The major version `0` is an exception. You shall not expect that any
-   version that starts with `0.` offers any kind of compatibility,
-   either source or binary, with any other `0.` version. (Of course I
-   will try to maintain some decent level of source compatibility, but I
-   make no promise in that respect. Since the API uses caller-allocated
-   context structures, I already know that binary compatibility _will_
-   be broken.)
-
- - Sub-versions (the `y` part) are about added functionality. That is,
-   it can be expected that `1.3` will contain some extra functions when
-   compared to `1.2`. The next version level (the `z` part) is for
-   bugfixes that do not add any functionality.

package/runtime/third_party/bearssl/VERSION

@@ -1 +0,0 @@
-7bea48e5e850ab4cafbe68d3765cdaba13a86d6f