@omnibuf/core 0.0.8 → 0.1.2
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/LICENSE +201 -21
- package/dist/blind.d.ts +3 -3
- package/dist/blind.d.ts.map +1 -1
- package/dist/blind.js +191 -31
- package/dist/blind.js.map +1 -1
- package/dist/encoder.d.ts +5 -5
- package/dist/encoder.d.ts.map +1 -1
- package/dist/encoder.js +25 -4
- package/dist/encoder.js.map +1 -1
- package/dist/protobuf-es.d.ts +2 -0
- package/dist/protobuf-es.d.ts.map +1 -1
- package/dist/protobuf-es.js +40 -8
- package/dist/protobuf-es.js.map +1 -1
- package/dist/readers.d.ts +4 -3
- package/dist/readers.d.ts.map +1 -1
- package/dist/readers.js +411 -120
- package/dist/readers.js.map +1 -1
- package/dist/schema.d.ts +15 -5
- package/dist/schema.d.ts.map +1 -1
- package/dist/schema.js +585 -205
- package/dist/schema.js.map +1 -1
- package/dist/validation.d.ts.map +1 -1
- package/dist/validation.js +16 -14
- package/dist/validation.js.map +1 -1
- package/dist/wire.d.ts +16 -3
- package/dist/wire.d.ts.map +1 -1
- package/dist/wire.js +441 -23
- package/dist/wire.js.map +1 -1
- package/package.json +2 -2
package/dist/wire.js
CHANGED
|
@@ -58,7 +58,7 @@ export function parseArrayHeader(body, start = 0, end = body.length) {
|
|
|
58
58
|
cn = 2;
|
|
59
59
|
}
|
|
60
60
|
else {
|
|
61
|
-
const [count64, cBytes] = decodeVarintBigInt(body, start + 1);
|
|
61
|
+
const [count64, cBytes] = decodeVarintBigInt(body, start + 1, end);
|
|
62
62
|
if (cBytes === 0 || count64 > BigInt(end - (start + 1 + cBytes))) {
|
|
63
63
|
return [0, 0, 0, false];
|
|
64
64
|
}
|
|
@@ -91,7 +91,7 @@ export function parseArrayHeader(body, start = 0, end = body.length) {
|
|
|
91
91
|
return [0, 0, 0, false];
|
|
92
92
|
}
|
|
93
93
|
}
|
|
94
|
-
else if (countNum > remaining) {
|
|
94
|
+
else if (countNum === 0 ? remaining !== 0 : countNum > remaining) {
|
|
95
95
|
return [0, 0, 0, false];
|
|
96
96
|
}
|
|
97
97
|
return [elemType, countNum, pos, true];
|
|
@@ -133,7 +133,7 @@ export function parseMapHeader(body, start = 0, end = body.length) {
|
|
|
133
133
|
cn = 2;
|
|
134
134
|
}
|
|
135
135
|
else {
|
|
136
|
-
const [count64, cBytes] = decodeVarintBigInt(body, start + 2);
|
|
136
|
+
const [count64, cBytes] = decodeVarintBigInt(body, start + 2, end);
|
|
137
137
|
if (cBytes === 0 || count64 > BigInt(Math.floor((end - (start + 2 + cBytes)) / 2))) {
|
|
138
138
|
return [0, 0, 0, 0, false];
|
|
139
139
|
}
|
|
@@ -141,7 +141,7 @@ export function parseMapHeader(body, start = 0, end = body.length) {
|
|
|
141
141
|
cn = cBytes;
|
|
142
142
|
}
|
|
143
143
|
const pos = start + 2 + cn;
|
|
144
|
-
if (pos > end || countNum > (end - pos) >>> 1) {
|
|
144
|
+
if (pos > end || (countNum === 0 ? end !== pos : countNum > (end - pos) >>> 1)) {
|
|
145
145
|
return [0, 0, 0, 0, false];
|
|
146
146
|
}
|
|
147
147
|
return [keyWT, valWT, countNum, pos, true];
|
|
@@ -153,6 +153,10 @@ const sharedTextDecoder = new TextDecoder('utf-8', { fatal: true, ignoreBOM: tru
|
|
|
153
153
|
* Returns `null` if any byte is non-ASCII (`>= 0x80`) or if `end - start > 64`.
|
|
154
154
|
*/
|
|
155
155
|
export function fastDecodeShortASCII(bytes, start, end) {
|
|
156
|
+
if (start < 0)
|
|
157
|
+
start = 0;
|
|
158
|
+
if (end > bytes.length)
|
|
159
|
+
end = bytes.length;
|
|
156
160
|
const len = end - start;
|
|
157
161
|
if (len <= 0)
|
|
158
162
|
return '';
|
|
@@ -364,18 +368,27 @@ export function decodeZigZagBigInt(u) {
|
|
|
364
368
|
return BigInt.asIntN(64, (b >> 1n) ^ -(b & 1n));
|
|
365
369
|
}
|
|
366
370
|
/**
|
|
367
|
-
* Maps a ZigZag-encoded unsigned integer back to a signed JS number
|
|
368
|
-
* or bigint (when outside Number.MAX_SAFE_INTEGER).
|
|
371
|
+
* Maps a ZigZag-encoded unsigned integer back to a signed JS number.
|
|
369
372
|
*/
|
|
370
373
|
export function decodeZigZag(u) {
|
|
371
374
|
if (typeof u === 'number' && u <= 0xffffffff) {
|
|
372
|
-
|
|
375
|
+
const res = (u >>> 1) ^ -(u & 1);
|
|
376
|
+
return res === 0 ? 0 : res;
|
|
373
377
|
}
|
|
374
|
-
const
|
|
375
|
-
|
|
376
|
-
|
|
378
|
+
const n = Number(decodeZigZagBigInt(u));
|
|
379
|
+
return n === 0 ? 0 : n;
|
|
380
|
+
}
|
|
381
|
+
/**
|
|
382
|
+
* Maps a ZigZag-encoded unsigned integer back to a signed 32-bit JS number,
|
|
383
|
+
* retaining the exact low 32 bits even when the wire value exceeds 2^53.
|
|
384
|
+
*/
|
|
385
|
+
export function decodeZigZag32(u) {
|
|
386
|
+
if (typeof u === 'number' && u <= 0xffffffff) {
|
|
387
|
+
const res = (u >>> 1) ^ -(u & 1);
|
|
388
|
+
return res === 0 ? 0 : res;
|
|
377
389
|
}
|
|
378
|
-
|
|
390
|
+
const n = Number(BigInt.asIntN(32, decodeZigZagBigInt(u)));
|
|
391
|
+
return n === 0 ? 0 : n;
|
|
379
392
|
}
|
|
380
393
|
/**
|
|
381
394
|
* Decodes a ZigZag value returning a JS number when within safe integer bounds,
|
|
@@ -767,7 +780,7 @@ function isValidArrayHeaderAt(body, start, end) {
|
|
|
767
780
|
case WireSfixed64:
|
|
768
781
|
return (remaining & 7) === 0 && countNum === remaining >>> 3;
|
|
769
782
|
default:
|
|
770
|
-
return countNum <= remaining;
|
|
783
|
+
return countNum === 0 ? remaining === 0 : countNum <= remaining;
|
|
771
784
|
}
|
|
772
785
|
}
|
|
773
786
|
function isValidMapHeaderAt(body, start, end) {
|
|
@@ -807,7 +820,7 @@ function isValidMapHeaderAt(body, start, end) {
|
|
|
807
820
|
cn = cBytes;
|
|
808
821
|
}
|
|
809
822
|
const pos = start + 2 + cn;
|
|
810
|
-
return pos <= end && countNum <= (end - pos) >>> 1;
|
|
823
|
+
return pos <= end && (countNum === 0 ? end === pos : countNum <= (end - pos) >>> 1);
|
|
811
824
|
}
|
|
812
825
|
export function skipValidatedValue(b, pos, wireType) {
|
|
813
826
|
const n = b.length;
|
|
@@ -911,6 +924,395 @@ export function skipValue(b, pos, wireType) {
|
|
|
911
924
|
}
|
|
912
925
|
return nextPos;
|
|
913
926
|
}
|
|
927
|
+
function validateUnknownEntryAt(body, p, wt, depth, limit) {
|
|
928
|
+
if (wt === WireBoolFalse) {
|
|
929
|
+
if (p >= body.length || (body[p] !== 0 && body[p] !== 1))
|
|
930
|
+
return -1;
|
|
931
|
+
return p + 1;
|
|
932
|
+
}
|
|
933
|
+
if (wt === WireSubMsg) {
|
|
934
|
+
if (p >= body.length)
|
|
935
|
+
return -1;
|
|
936
|
+
const [bLen, bn] = decodeVarintBigInt(body, p);
|
|
937
|
+
if (bn === 0 || bLen > BigInt(body.length - (p + bn)))
|
|
938
|
+
return -1;
|
|
939
|
+
const start = p + bn;
|
|
940
|
+
const end = start + Number(bLen);
|
|
941
|
+
if (!validateUnknownMessageBytes(body.subarray(start, end), depth + 1, limit))
|
|
942
|
+
return -1;
|
|
943
|
+
return end;
|
|
944
|
+
}
|
|
945
|
+
if (wt === WireArray || wt === WireMap) {
|
|
946
|
+
return validateUnknownValueAt(body, p, wt, depth, limit);
|
|
947
|
+
}
|
|
948
|
+
return skipValidatedValue(body, p, wt);
|
|
949
|
+
}
|
|
950
|
+
function validateUnknownValueAt(data, pos, wt, depth, limit) {
|
|
951
|
+
if (depth > limit)
|
|
952
|
+
return -1;
|
|
953
|
+
if (wt === WireSubMsg) {
|
|
954
|
+
if (pos >= data.length)
|
|
955
|
+
return -1;
|
|
956
|
+
const [bLen, bn] = decodeVarintBigInt(data, pos);
|
|
957
|
+
if (bn === 0 || bLen > BigInt(data.length - (pos + bn)))
|
|
958
|
+
return -1;
|
|
959
|
+
const start = pos + bn;
|
|
960
|
+
const end = start + Number(bLen);
|
|
961
|
+
if (!validateUnknownMessageBytes(data.subarray(start, end), depth + 1, limit))
|
|
962
|
+
return -1;
|
|
963
|
+
return end;
|
|
964
|
+
}
|
|
965
|
+
if (wt === WireArray) {
|
|
966
|
+
if (depth + 1 > limit || pos >= data.length)
|
|
967
|
+
return -1;
|
|
968
|
+
const [bLen, bn] = decodeVarintBigInt(data, pos);
|
|
969
|
+
if (bn === 0 || bLen < 2n || bLen > BigInt(data.length - (pos + bn)))
|
|
970
|
+
return -1;
|
|
971
|
+
const end = pos + bn + Number(bLen);
|
|
972
|
+
const body = data.subarray(pos + bn, end);
|
|
973
|
+
const [elemType, count, startP, ok] = parseArrayHeader(body);
|
|
974
|
+
if (!ok)
|
|
975
|
+
return -1;
|
|
976
|
+
let p = startP;
|
|
977
|
+
if (elemType === WireBoolFalse) {
|
|
978
|
+
if (body.length - p !== count)
|
|
979
|
+
return -1;
|
|
980
|
+
for (let i = 0; i < count; i++) {
|
|
981
|
+
const b = body[p + i];
|
|
982
|
+
if (b !== 0 && b !== 1)
|
|
983
|
+
return -1;
|
|
984
|
+
}
|
|
985
|
+
return end;
|
|
986
|
+
}
|
|
987
|
+
if (elemType === WireFixed32 || elemType === WireSfixed32 || elemType === WireFloat32) {
|
|
988
|
+
return body.length - p === count * 4 ? end : -1;
|
|
989
|
+
}
|
|
990
|
+
if (elemType === WireFixed64 || elemType === WireSfixed64 || elemType === WireFloat64) {
|
|
991
|
+
return body.length - p === count * 8 ? end : -1;
|
|
992
|
+
}
|
|
993
|
+
for (let i = 0; i < count; i++) {
|
|
994
|
+
p = validateUnknownEntryAt(body, p, elemType, depth + 1, limit);
|
|
995
|
+
if (p < 0)
|
|
996
|
+
return -1;
|
|
997
|
+
}
|
|
998
|
+
return p === body.length ? end : -1;
|
|
999
|
+
}
|
|
1000
|
+
if (wt === WireMap) {
|
|
1001
|
+
if (depth + 1 > limit || pos >= data.length)
|
|
1002
|
+
return -1;
|
|
1003
|
+
const [bLen, bn] = decodeVarintBigInt(data, pos);
|
|
1004
|
+
if (bn === 0 || bLen < 3n || bLen > BigInt(data.length - (pos + bn)))
|
|
1005
|
+
return -1;
|
|
1006
|
+
const end = pos + bn + Number(bLen);
|
|
1007
|
+
const body = data.subarray(pos + bn, end);
|
|
1008
|
+
const [keyWT, valWT, count, startP, ok] = parseMapHeader(body);
|
|
1009
|
+
if (!ok)
|
|
1010
|
+
return -1;
|
|
1011
|
+
let p = startP;
|
|
1012
|
+
for (let i = 0; i < count; i++) {
|
|
1013
|
+
p = validateUnknownEntryAt(body, p, keyWT, depth + 1, limit);
|
|
1014
|
+
if (p < 0)
|
|
1015
|
+
return -1;
|
|
1016
|
+
p = validateUnknownEntryAt(body, p, valWT, depth + 1, limit);
|
|
1017
|
+
if (p < 0)
|
|
1018
|
+
return -1;
|
|
1019
|
+
}
|
|
1020
|
+
return p === body.length ? end : -1;
|
|
1021
|
+
}
|
|
1022
|
+
return skipValidatedValue(data, pos, wt);
|
|
1023
|
+
}
|
|
1024
|
+
function validateUnknownMessageBytes(data, depth, limit = MaxNestingDepth) {
|
|
1025
|
+
if (depth > limit)
|
|
1026
|
+
return false;
|
|
1027
|
+
let pos = 0;
|
|
1028
|
+
while (pos < data.length) {
|
|
1029
|
+
const [tag, tn] = decodeVarintBigInt(data, pos);
|
|
1030
|
+
if (tn === 0 || tag >> 4n > 536870911n)
|
|
1031
|
+
return false;
|
|
1032
|
+
pos += tn;
|
|
1033
|
+
const fnum = Number(tag >> 4n);
|
|
1034
|
+
const wt = Number(tag & 0x0fn);
|
|
1035
|
+
if (fnum === 0) {
|
|
1036
|
+
const nextPos = validateField0At(data, pos, wt, depth, limit);
|
|
1037
|
+
if (nextPos < 0)
|
|
1038
|
+
return false;
|
|
1039
|
+
pos = nextPos;
|
|
1040
|
+
}
|
|
1041
|
+
else {
|
|
1042
|
+
const nextPos = validateUnknownValueAt(data, pos, wt, depth, limit);
|
|
1043
|
+
if (nextPos < 0)
|
|
1044
|
+
return false;
|
|
1045
|
+
pos = nextPos;
|
|
1046
|
+
}
|
|
1047
|
+
}
|
|
1048
|
+
return true;
|
|
1049
|
+
}
|
|
1050
|
+
function isValidUTF8Slice(bytes, start, end) {
|
|
1051
|
+
for (let i = start; i < end; i++) {
|
|
1052
|
+
if (bytes[i] >= 0x80) {
|
|
1053
|
+
try {
|
|
1054
|
+
sharedTextDecoder.decode(bytes.subarray(start, end));
|
|
1055
|
+
return true;
|
|
1056
|
+
}
|
|
1057
|
+
catch {
|
|
1058
|
+
return false;
|
|
1059
|
+
}
|
|
1060
|
+
}
|
|
1061
|
+
}
|
|
1062
|
+
return true;
|
|
1063
|
+
}
|
|
1064
|
+
/**
|
|
1065
|
+
* Validates an `omnibuf.v1.SchemaMeta` payload at `depth`.
|
|
1066
|
+
*/
|
|
1067
|
+
export function validateSchemaMetaBytes(data, depth, limit = MaxNestingDepth, start = 0, endLimit = data.length) {
|
|
1068
|
+
if (depth > limit)
|
|
1069
|
+
return false;
|
|
1070
|
+
let pos = start;
|
|
1071
|
+
const n = endLimit;
|
|
1072
|
+
while (pos < n) {
|
|
1073
|
+
let fnum = 0;
|
|
1074
|
+
let wt = 0;
|
|
1075
|
+
const tb = data[pos];
|
|
1076
|
+
if ((tb & 1) !== 0) {
|
|
1077
|
+
fnum = tb >>> 5;
|
|
1078
|
+
wt = (tb >>> 1) & 0x0f;
|
|
1079
|
+
pos += 1;
|
|
1080
|
+
}
|
|
1081
|
+
else if ((tb & 2) !== 0) {
|
|
1082
|
+
if (pos + 2 > n)
|
|
1083
|
+
return false;
|
|
1084
|
+
const u16 = (tb | (data[pos + 1] << 8)) >>> 2;
|
|
1085
|
+
fnum = u16 >>> 4;
|
|
1086
|
+
wt = u16 & 0x0f;
|
|
1087
|
+
pos += 2;
|
|
1088
|
+
}
|
|
1089
|
+
else {
|
|
1090
|
+
const [tag, tn] = decodeVarintBigInt(data, pos, n);
|
|
1091
|
+
if (tn === 0 || tag >> 4n > 536870911n)
|
|
1092
|
+
return false;
|
|
1093
|
+
pos += tn;
|
|
1094
|
+
fnum = Number(tag >> 4n);
|
|
1095
|
+
wt = Number(tag & 0x0fn);
|
|
1096
|
+
}
|
|
1097
|
+
switch (fnum) {
|
|
1098
|
+
case 1: {
|
|
1099
|
+
if (wt !== WireString || pos >= n)
|
|
1100
|
+
return false;
|
|
1101
|
+
let sLen = 0;
|
|
1102
|
+
const sb = data[pos];
|
|
1103
|
+
if ((sb & 1) !== 0) {
|
|
1104
|
+
sLen = sb >>> 1;
|
|
1105
|
+
pos += 1;
|
|
1106
|
+
}
|
|
1107
|
+
else {
|
|
1108
|
+
const [sl64, sn] = decodeVarintBigInt(data, pos, n);
|
|
1109
|
+
if (sn === 0 || sl64 > BigInt(n - (pos + sn)))
|
|
1110
|
+
return false;
|
|
1111
|
+
pos += sn;
|
|
1112
|
+
sLen = Number(sl64);
|
|
1113
|
+
}
|
|
1114
|
+
const end = pos + sLen;
|
|
1115
|
+
if (end > n || !isValidUTF8Slice(data, pos, end))
|
|
1116
|
+
return false;
|
|
1117
|
+
pos = end;
|
|
1118
|
+
break;
|
|
1119
|
+
}
|
|
1120
|
+
case 2: {
|
|
1121
|
+
if (wt !== WireMap || depth + 1 > limit || pos >= n)
|
|
1122
|
+
return false;
|
|
1123
|
+
let bLen = 0;
|
|
1124
|
+
const lb = data[pos];
|
|
1125
|
+
if ((lb & 1) !== 0) {
|
|
1126
|
+
bLen = lb >>> 1;
|
|
1127
|
+
pos += 1;
|
|
1128
|
+
}
|
|
1129
|
+
else if ((lb & 2) !== 0) {
|
|
1130
|
+
if (pos + 2 > n)
|
|
1131
|
+
return false;
|
|
1132
|
+
bLen = (lb | (data[pos + 1] << 8)) >>> 2;
|
|
1133
|
+
pos += 2;
|
|
1134
|
+
}
|
|
1135
|
+
else {
|
|
1136
|
+
const [bl64, bn] = decodeVarintBigInt(data, pos, n);
|
|
1137
|
+
if (bn === 0 || bl64 > BigInt(n - (pos + bn)))
|
|
1138
|
+
return false;
|
|
1139
|
+
pos += bn;
|
|
1140
|
+
bLen = Number(bl64);
|
|
1141
|
+
}
|
|
1142
|
+
const bodyEnd = pos + bLen;
|
|
1143
|
+
if (bLen < 3 || bodyEnd > n)
|
|
1144
|
+
return false;
|
|
1145
|
+
const [keyWT, valWT, count, startP, ok] = parseMapHeader(data, pos, bodyEnd);
|
|
1146
|
+
if (!ok || keyWT !== WireUint || valWT !== WireString)
|
|
1147
|
+
return false;
|
|
1148
|
+
let p = startP;
|
|
1149
|
+
for (let i = 0; i < count; i++) {
|
|
1150
|
+
if (p >= bodyEnd)
|
|
1151
|
+
return false;
|
|
1152
|
+
let kNum = 0;
|
|
1153
|
+
const kb = data[p];
|
|
1154
|
+
if ((kb & 1) !== 0) {
|
|
1155
|
+
kNum = kb >>> 1;
|
|
1156
|
+
p += 1;
|
|
1157
|
+
}
|
|
1158
|
+
else {
|
|
1159
|
+
const [k64, kn] = decodeVarintBigInt(data, p, bodyEnd);
|
|
1160
|
+
if (kn === 0 || k64 === 0n || k64 > 536870911n)
|
|
1161
|
+
return false;
|
|
1162
|
+
p += kn;
|
|
1163
|
+
kNum = Number(k64);
|
|
1164
|
+
}
|
|
1165
|
+
if (kNum === 0 || kNum > 536870911 || p >= bodyEnd)
|
|
1166
|
+
return false;
|
|
1167
|
+
let sLen = 0;
|
|
1168
|
+
const sb = data[p];
|
|
1169
|
+
if ((sb & 1) !== 0) {
|
|
1170
|
+
sLen = sb >>> 1;
|
|
1171
|
+
p += 1;
|
|
1172
|
+
}
|
|
1173
|
+
else {
|
|
1174
|
+
const [sl64, sn] = decodeVarintBigInt(data, p, bodyEnd);
|
|
1175
|
+
if (sn === 0 || sl64 > BigInt(bodyEnd - (p + sn)))
|
|
1176
|
+
return false;
|
|
1177
|
+
p += sn;
|
|
1178
|
+
sLen = Number(sl64);
|
|
1179
|
+
}
|
|
1180
|
+
const sEnd = p + sLen;
|
|
1181
|
+
if (sEnd > bodyEnd || !isValidUTF8Slice(data, p, sEnd))
|
|
1182
|
+
return false;
|
|
1183
|
+
p = sEnd;
|
|
1184
|
+
}
|
|
1185
|
+
if (p !== bodyEnd)
|
|
1186
|
+
return false;
|
|
1187
|
+
pos = bodyEnd;
|
|
1188
|
+
break;
|
|
1189
|
+
}
|
|
1190
|
+
case 3: {
|
|
1191
|
+
if (wt !== WireMap || depth + 1 > limit || pos >= n)
|
|
1192
|
+
return false;
|
|
1193
|
+
let bLen = 0;
|
|
1194
|
+
const lb = data[pos];
|
|
1195
|
+
if ((lb & 1) !== 0) {
|
|
1196
|
+
bLen = lb >>> 1;
|
|
1197
|
+
pos += 1;
|
|
1198
|
+
}
|
|
1199
|
+
else if ((lb & 2) !== 0) {
|
|
1200
|
+
if (pos + 2 > n)
|
|
1201
|
+
return false;
|
|
1202
|
+
bLen = (lb | (data[pos + 1] << 8)) >>> 2;
|
|
1203
|
+
pos += 2;
|
|
1204
|
+
}
|
|
1205
|
+
else {
|
|
1206
|
+
const [bl64, bn] = decodeVarintBigInt(data, pos, n);
|
|
1207
|
+
if (bn === 0 || bl64 > BigInt(n - (pos + bn)))
|
|
1208
|
+
return false;
|
|
1209
|
+
pos += bn;
|
|
1210
|
+
bLen = Number(bl64);
|
|
1211
|
+
}
|
|
1212
|
+
const bodyEnd = pos + bLen;
|
|
1213
|
+
if (bLen < 3 || bodyEnd > n)
|
|
1214
|
+
return false;
|
|
1215
|
+
const [keyWT, valWT, count, startP, ok] = parseMapHeader(data, pos, bodyEnd);
|
|
1216
|
+
if (!ok || keyWT !== WireUint || valWT !== WireSubMsg)
|
|
1217
|
+
return false;
|
|
1218
|
+
let p = startP;
|
|
1219
|
+
for (let i = 0; i < count; i++) {
|
|
1220
|
+
if (p >= bodyEnd)
|
|
1221
|
+
return false;
|
|
1222
|
+
let kNum = 0;
|
|
1223
|
+
const kb = data[p];
|
|
1224
|
+
if ((kb & 1) !== 0) {
|
|
1225
|
+
kNum = kb >>> 1;
|
|
1226
|
+
p += 1;
|
|
1227
|
+
}
|
|
1228
|
+
else {
|
|
1229
|
+
const [k64, kn] = decodeVarintBigInt(data, p, bodyEnd);
|
|
1230
|
+
if (kn === 0 || k64 === 0n || k64 > 536870911n)
|
|
1231
|
+
return false;
|
|
1232
|
+
p += kn;
|
|
1233
|
+
kNum = Number(k64);
|
|
1234
|
+
}
|
|
1235
|
+
if (kNum === 0 || kNum > 536870911 || p >= bodyEnd)
|
|
1236
|
+
return false;
|
|
1237
|
+
let cLen = 0;
|
|
1238
|
+
const cb = data[p];
|
|
1239
|
+
if ((cb & 1) !== 0) {
|
|
1240
|
+
cLen = cb >>> 1;
|
|
1241
|
+
p += 1;
|
|
1242
|
+
}
|
|
1243
|
+
else if ((cb & 2) !== 0) {
|
|
1244
|
+
if (p + 2 > bodyEnd)
|
|
1245
|
+
return false;
|
|
1246
|
+
cLen = (cb | (data[p + 1] << 8)) >>> 2;
|
|
1247
|
+
p += 2;
|
|
1248
|
+
}
|
|
1249
|
+
else {
|
|
1250
|
+
const [cl64, cn] = decodeVarintBigInt(data, p, bodyEnd);
|
|
1251
|
+
if (cn === 0 || cl64 > BigInt(bodyEnd - (p + cn)))
|
|
1252
|
+
return false;
|
|
1253
|
+
p += cn;
|
|
1254
|
+
cLen = Number(cl64);
|
|
1255
|
+
}
|
|
1256
|
+
const cEnd = p + cLen;
|
|
1257
|
+
if (cEnd > bodyEnd || !validateSchemaMetaBytes(data, depth + 2, limit, p, cEnd)) {
|
|
1258
|
+
return false;
|
|
1259
|
+
}
|
|
1260
|
+
p = cEnd;
|
|
1261
|
+
}
|
|
1262
|
+
if (p !== bodyEnd)
|
|
1263
|
+
return false;
|
|
1264
|
+
pos = bodyEnd;
|
|
1265
|
+
break;
|
|
1266
|
+
}
|
|
1267
|
+
default: {
|
|
1268
|
+
if (fnum === 0)
|
|
1269
|
+
return false;
|
|
1270
|
+
const sub = n === data.length ? data : data.subarray(0, n);
|
|
1271
|
+
const nextPos = validateUnknownValueAt(sub, pos, wt, depth, limit);
|
|
1272
|
+
if (nextPos < 0)
|
|
1273
|
+
return false;
|
|
1274
|
+
pos = nextPos;
|
|
1275
|
+
break;
|
|
1276
|
+
}
|
|
1277
|
+
}
|
|
1278
|
+
}
|
|
1279
|
+
return true;
|
|
1280
|
+
}
|
|
1281
|
+
/**
|
|
1282
|
+
* Validates a `Field #0` (`omnibuf.v1.SchemaMeta`) entry starting at value offset `pos`.
|
|
1283
|
+
* Returns the end offset after `Field #0`, or `-1` if invalid.
|
|
1284
|
+
*/
|
|
1285
|
+
export function validateField0At(packet, pos, wt, depth = 0, limit = MaxNestingDepth, endLimit = packet.length) {
|
|
1286
|
+
if (wt !== WireSubMsg || pos < 0 || pos >= endLimit)
|
|
1287
|
+
return -1;
|
|
1288
|
+
let bLen = 0;
|
|
1289
|
+
let bn = 0;
|
|
1290
|
+
const lb = packet[pos];
|
|
1291
|
+
if ((lb & 1) !== 0) {
|
|
1292
|
+
bLen = lb >>> 1;
|
|
1293
|
+
bn = 1;
|
|
1294
|
+
}
|
|
1295
|
+
else if ((lb & 2) !== 0) {
|
|
1296
|
+
if (pos + 2 > endLimit)
|
|
1297
|
+
return -1;
|
|
1298
|
+
bLen = (lb | (packet[pos + 1] << 8)) >>> 2;
|
|
1299
|
+
bn = 2;
|
|
1300
|
+
}
|
|
1301
|
+
else {
|
|
1302
|
+
const [bl64, nBytes] = decodeVarintBigInt(packet, pos, endLimit);
|
|
1303
|
+
if (nBytes === 0 || bl64 > BigInt(endLimit - (pos + nBytes)))
|
|
1304
|
+
return -1;
|
|
1305
|
+
bLen = Number(bl64);
|
|
1306
|
+
bn = nBytes;
|
|
1307
|
+
}
|
|
1308
|
+
const start = pos + bn;
|
|
1309
|
+
const end = start + bLen;
|
|
1310
|
+
if (end > endLimit)
|
|
1311
|
+
return -1;
|
|
1312
|
+
if (!validateSchemaMetaBytes(packet, depth + 1, limit, start, end))
|
|
1313
|
+
return -1;
|
|
1314
|
+
return end;
|
|
1315
|
+
}
|
|
914
1316
|
const NOT_FOUND = {
|
|
915
1317
|
valSlice: new Uint8Array(0),
|
|
916
1318
|
valPos: 0,
|
|
@@ -922,7 +1324,7 @@ const NOT_FOUND = {
|
|
|
922
1324
|
* using TZCNT length prefixes (without parsing inside preceding strings, sub-messages, or arrays).
|
|
923
1325
|
* Scans all field headers in the message and returns the last matching occurrence ("last write wins").
|
|
924
1326
|
*/
|
|
925
|
-
export function locateField(packet, targetField) {
|
|
1327
|
+
export function locateField(packet, targetField, expMask = 0xffff) {
|
|
926
1328
|
let pos = 0;
|
|
927
1329
|
const n = packet.length;
|
|
928
1330
|
let lastPos = -1;
|
|
@@ -953,10 +1355,19 @@ export function locateField(packet, targetField) {
|
|
|
953
1355
|
wt = Number(tag & 0x0fn);
|
|
954
1356
|
pos += tn;
|
|
955
1357
|
}
|
|
956
|
-
if (fnum === 0
|
|
957
|
-
|
|
1358
|
+
if (fnum === 0) {
|
|
1359
|
+
const f0End = validateField0At(packet, pos, wt, 0);
|
|
1360
|
+
if (f0End < 0) {
|
|
1361
|
+
return NOT_FOUND;
|
|
1362
|
+
}
|
|
1363
|
+
if (targetField === 0 && ((expMask >>> wt) & 1) !== 0) {
|
|
1364
|
+
lastPos = pos;
|
|
1365
|
+
lastWT = wt;
|
|
1366
|
+
}
|
|
1367
|
+
pos = f0End;
|
|
1368
|
+
continue;
|
|
958
1369
|
}
|
|
959
|
-
if (fnum === targetField) {
|
|
1370
|
+
if (fnum === targetField && ((expMask >>> wt) & 1) !== 0) {
|
|
960
1371
|
lastPos = pos;
|
|
961
1372
|
lastWT = wt;
|
|
962
1373
|
}
|
|
@@ -1009,11 +1420,19 @@ export function nextContainerField(packet, pos, targetField, expWT, minLen) {
|
|
|
1009
1420
|
wt = Number(tag & 0x0fn);
|
|
1010
1421
|
pos += tn;
|
|
1011
1422
|
}
|
|
1423
|
+
if (fnum === 0 && targetField !== 0) {
|
|
1424
|
+
const f0End = validateField0At(packet, pos, wt, 0);
|
|
1425
|
+
if (f0End < 0) {
|
|
1426
|
+
return { body: new Uint8Array(0), nextPos: 0, matched: false, valid: false };
|
|
1427
|
+
}
|
|
1428
|
+
pos = f0End;
|
|
1429
|
+
continue;
|
|
1430
|
+
}
|
|
1012
1431
|
if (fnum === 0 && wt !== WireSubMsg) {
|
|
1013
1432
|
return { body: new Uint8Array(0), nextPos: 0, matched: false, valid: false };
|
|
1014
1433
|
}
|
|
1015
|
-
if (fnum === targetField) {
|
|
1016
|
-
if (
|
|
1434
|
+
if (fnum === targetField && wt === expWT) {
|
|
1435
|
+
if (pos >= n) {
|
|
1017
1436
|
return { body: new Uint8Array(0), nextPos: 0, matched: false, valid: false };
|
|
1018
1437
|
}
|
|
1019
1438
|
let lenNum = 0;
|
|
@@ -1050,12 +1469,11 @@ export function nextContainerField(packet, pos, targetField, expWT, minLen) {
|
|
|
1050
1469
|
valid: true,
|
|
1051
1470
|
};
|
|
1052
1471
|
}
|
|
1053
|
-
|
|
1054
|
-
|
|
1055
|
-
}
|
|
1056
|
-
catch {
|
|
1472
|
+
const nextPos = skipValidatedValue(packet, pos, wt);
|
|
1473
|
+
if (nextPos < 0) {
|
|
1057
1474
|
return { body: new Uint8Array(0), nextPos: 0, matched: false, valid: false };
|
|
1058
1475
|
}
|
|
1476
|
+
pos = nextPos;
|
|
1059
1477
|
}
|
|
1060
1478
|
return { body: new Uint8Array(0), nextPos: n, matched: false, valid: true };
|
|
1061
1479
|
}
|