typepki-strconv 0.1.0

package/src/conv.test.mts

@@ -0,0 +1,99 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+  Dictionary,
+  VERSION,
+  aryval,
+  b64tob64u,
+  b64tohex,
+  b64utob64,
+  b64utohex,
+  binstrtobitstr,
+  hextob64,
+  hextob64u,
+  hextorstr,
+  inttobitstr,
+  namearraytobinstr,
+  rstrtob64,
+  rstrtohex,
+  strpad,
+} from "./index.mts";
+
+// ==== VERSION ===========================================
+test("VERSION", () => {
+  expect(VERSION.substr(0, 16)).toBe("typepki-strconv ");
+});
+
+// ==== hex / base64 ======================================
+test("b64tohex", () => {
+  expect(b64tohex("YWFh")).toBe("616161");
+});
+
+test("hextob64", () => {
+  expect(hextob64("616161")).toBe("YWFh");
+});
+
+// ==== hex / base64u =====================================
+test("b64utohex", () => {
+  expect(b64utohex("YWFh")).toBe("616161");
+});
+
+test("hextob64u", () => {
+  expect(hextob64u("616161")).toBe("YWFh");
+});
+
+// ==== base64 / base64u ==================================
+
+test("b64tob64u", () => {
+  expect(b64tob64u("ab+c3f/==")).toBe("ab-c3f_");
+  expect(b64utob64("ab-c3f_")).toBe("ab+c3f/="); // ?? いいの？
+});
+
+test("binstrtobitstr", () => {
+  expect(binstrtobitstr("101")).toBe("05a0");
+});
+
+test("inttobitstr", () => {
+  expect(inttobitstr(0b11001)).toBe("03c8");
+  expect(inttobitstr(0b101)).toBe("05a0");
+  expect(inttobitstr(0b101000001)).toBe("07a080");
+});
+
+test("strpad", () => {
+  expect(strpad("1234", 10, "0")).toBe("0000001234");
+  expect(strpad("1234", 10, " ")).toBe("      1234");
+  expect(strpad("1234", 10)).toBe("0000001234");
+});
+
+test("namearraytobinstr", () => {
+  const db: Dictionary<number> = { a: 0, b: 3, c: 8, d: 9, e: 17, f: 19 };
+  expect(namearraytobinstr(["a", "c", "d"], db)).toBe("1000000011");
+  expect(namearraytobinstr(["c", "b"], db)).toBe("000100001");
+});
+
+test("aryval", () => {
+  const p = {
+    fruit: "apple",
+    info: [{ toy: 4 }, { pen: 6 }],
+  };
+  expect(aryval(p, "fruit")).toBe("apple");
+  expect(aryval(p, "info")).toEqual([{ toy: 4 }, { pen: 6 }]);
+  expect(aryval(p, "info.1")).toEqual({ pen: 6 });
+  expect(aryval(p, "info.1.pen")).toBe(6);
+  expect(aryval(p, "money.amount")).toBe(undefined);
+  expect(aryval(p, "money.amount", null)).toBe(null);
+});
+
+test("hextorstr", () => {
+  expect(hextorstr("616161")).toBe("aaa");
+  expect(hextorstr("000000")).toBe("\x00\x00\x00");
+});
+
+test("rstrtohex", () => {
+  expect(rstrtohex("aaa")).toBe("616161");
+  expect(rstrtohex("\x00\x00\x00")).toBe("000000");
+});
+
+test("rstrtob64", () => {
+  expect(rstrtob64("aaa")).toBe("YWFh");
+});

package/src/conv_arybuf.mts

@@ -0,0 +1,53 @@
+/**
+ * convert a hexadecimal string to an ArrayBuffer
+ * @param hex - hexadecimal string
+ * @return ArrayBuffer
+ *
+ * @description
+ * This function converts from a hexadecimal string to an ArrayBuffer.
+ *
+ * @example
+ * hextoArrayBuffer("fffa01") -> ArrayBuffer of [255, 250, 1]
+ */
+export function hextoArrayBuffer(hex: string): ArrayBuffer {
+  if (hex.length % 2 !== 0) throw "input is not even length";
+  if (hex.match(/^[0-9A-Fa-f]+$/) == null) throw "input is not hexadecimal";
+
+  const buffer = new ArrayBuffer(hex.length / 2);
+  const view = new DataView(buffer);
+
+  for (let i = 0; i < hex.length / 2; i++) {
+    view.setUint8(i, parseInt(hex.substr(i * 2, 2), 16));
+  }
+
+  return buffer;
+}
+
+// ==== ArrayBuffer / hex =================================
+
+/**
+ * convert an ArrayBuffer to a hexadecimal string
+ * @param buffer - ArrayBuffer
+ * @return hexadecimal string
+ *
+ * @description
+ * This function converts from an ArrayBuffer to a hexadecimal string.
+ *
+ * @example
+ * var buffer = new ArrayBuffer(3);
+ * var view = new DataView(buffer);
+ * view.setUint8(0, 0xfa);
+ * view.setUint8(1, 0xfb);
+ * view.setUint8(2, 0x01);
+ * ArrayBuffertohex(buffer) -> "fafb01"
+ */
+export function ArrayBuffertohex(buffer: ArrayBuffer): string {
+  let hex = "";
+  const view = new DataView(buffer);
+
+  for (let i = 0; i < buffer.byteLength; i++) {
+    hex += `00${view.getUint8(i).toString(16)}`.slice(-2);
+  }
+
+  return hex;
+}

package/src/conv_arybuf.test.mts

@@ -0,0 +1,16 @@
+import { describe, expect, test } from "bun:test";
+
+import { ArrayBuffertohex, hextoArrayBuffer } from "./index.mts";
+
+const buf = new ArrayBuffer(3);
+const ui8a = new Uint8Array(buf);
+ui8a[0] = 1;
+ui8a[2] = 1;
+
+test("hextoArrayBuffer", () => {
+  expect(hextoArrayBuffer("010001")).toStrictEqual(buf);
+});
+
+test("ArrayBuffertohex", () => {
+  expect(ArrayBuffertohex(buf)).toBe("010001");
+});

package/src/conv_ba.mts

@@ -0,0 +1,52 @@
+/**
+ * convert a ASCII string to a hexadecimal string of ASCII codes.
+ * @description
+ * NOTE: This can't be used for non ASCII characters.
+ * @param s - ASCII string
+ * @return hexadecimal string
+ */
+export function stohex(s: string): string {
+  return BAtohex(stoBA(s));
+}
+
+/**
+ * convert an array of bytes(Number) to hexadecimal string.
+ * @param a - a array of bytes
+ * @return hexadecimal string
+ */
+export function BAtohex(a: Array<number>): string {
+  let s = "";
+  for (let i = 0; i < a.length; i++) {
+    let hex1 = a[i].toString(16);
+    if (hex1.length === 1) hex1 = `0${hex1}`;
+    s = s + hex1;
+  }
+  return s;
+}
+
+// ==== string / byte array ================================
+/**
+ * convert a string to an array of character codes
+ * @param s - string
+ * @return array of character code value
+ */
+export function stoBA(s: string): Array<number> {
+  const a = new Array();
+  for (let i = 0; i < s.length; i++) {
+    a[i] = s.charCodeAt(i);
+  }
+  return a;
+}
+
+/**
+ * convert an array of character codes to a string
+ * @param a - a array of character codes
+ * @return string
+ */
+export function BAtos(a: Array<number>): string {
+  let s = "";
+  for (let i = 0; i < a.length; i++) {
+    s = s + String.fromCharCode(a[i]);
+  }
+  return s;
+}

package/src/conv_ip.mts

@@ -0,0 +1,226 @@
+/**
+ * convert any IPv6 address to a 16 byte hexadecimal string
+ * @param sIn - ipv6 address string
+ * @return 16 byte hexadecimal string of IPv6 address
+ *
+ * @description
+ * This function converts any IPv6 address representation string
+ * to a 16 byte hexadecimal string of address.
+ *
+ * @example
+ */
+export function ipv6tohex(sIn: string): string {
+  let s: string = sIn;
+  const msgMalformedAddress = "malformed IPv6 address";
+  if (!s.match(/^[0-9A-Fa-f:]+$/)) throw msgMalformedAddress;
+
+  // 1. downcase
+  s = s.toLowerCase();
+
+  // 2. expand ::
+  const num_colon = s.split(":").length - 1;
+  if (num_colon < 2) throw msgMalformedAddress;
+  const colon_replacer = ":".repeat(7 - num_colon + 2);
+  s = s.replace("::", colon_replacer);
+
+  // 3. fill zero
+  const a = s.split(":");
+  if (a.length !== 8) throw msgMalformedAddress;
+  for (let i = 0; i < 8; i++) {
+    a[i] = `0000${a[i]}`.slice(-4);
+  }
+  return a.join("");
+}
+
+/**
+ * convert a 16 byte hexadecimal string to RFC 5952 canonicalized IPv6 address
+ * @param hex - hexadecimal string of 16 byte IPv6 address
+ * @return IPv6 address string canonicalized by RFC 5952
+ *
+ * @description
+ * This function converts a 16 byte hexadecimal string to
+ * <a href="https://tools.ietf.org/html/rfc5952">RFC 5952</a>
+ * canonicalized IPv6 address string.
+ *
+ * @example
+ * hextoipv6("871020010db8000000000000000000000004") -> "2001:db8::4"
+ * hextoipv6("871020010db8000000000000000000") -> raise exception
+ * hextoipv6("xyzxyzxyzxyzxyzxyzxyzxyzxyzxyzxyzxyz") -> raise exception
+ */
+export function hextoipv6(hex: string): string {
+  let s: string = hex;
+  if (!s.match(/^[0-9A-Fa-f]{32}$/))
+    throw new Error(`malformed IPv6 address: ${s}`);
+
+  // 1. downcase
+  s = s.toLowerCase();
+
+  // 2. split 4 > ["0123", "00a4", "0000", ..., "ffff"]
+  let a: string[] = s.match(/.{1,4}/g) || [];
+
+  // 3. trim leading 0 for items and join > "123:a4:0:...:ffff"
+  a = a.map((s) => s.replace(/^0+/, ""));
+  a = a.map((s) => (s === "" ? "0" : s));
+  s = `:${a.join(":")}:`;
+
+  // 4. find shrinkable candidates :0:0:..:0:
+  const aZero = s.match(/:(0:){2,}/g);
+
+  // 5. no shrinkable
+  if (aZero == null) return s.slice(1, -1);
+
+  // 6. fix max length zero(:0:...:0:)
+  const sMaxZero = aZero.sort().slice(-1)[0];
+
+  // 7. replace shrinked
+  s = s.replace(sMaxZero.substr(0, sMaxZero.length - 1), ":");
+
+  // 8. trim leading ':' if not '::'
+  if (s.substr(0, 2) !== "::") s = s.substr(1);
+
+  // 9. trim tail ':' if not '::'
+  if (s.substr(-2, 2) !== "::") s = s.substr(0, s.length - 1);
+
+  return s;
+}
+
+/*
+ * @see hextoipv6
+ * @see iptohex
+ */
+/**
+ * convert a hexadecimal string to IP addresss
+ * @param s - hexadecimal string of IP address
+ * @return IP address string
+ *
+ * @description
+ * This function converts a hexadecimal string of IPv4 or
+ * IPv6 address to IPv4 or IPv6 address string.
+ * If byte length is not 4 nor 16, this returns a
+ * hexadecimal string without conversion.
+ *
+ * @example
+ * hextoip("c0a80101") -> "192.168.1.1"
+ * hextoip("871020010db8000000000000000000000004") -> "2001:db8::4"
+ * hextoip("c0a80100ffffff00") -> "192.168.1.0/24"
+ * hextoip("c0a801010203") -> "c0a801010203" // wrong 6 bytes
+ * hextoip("zzz")) -> raise exception because of not hexadecimal
+ */
+export function hextoip(s: string): string {
+  const malformedErr = new Error("malformed hex value");
+  if (!s.match(/^([0-9A-Fa-f][0-9A-Fa-f]){1,}$/)) throw malformedErr;
+  if (s.length === 8) {
+    // ipv4
+    let ip: string;
+    try {
+      ip = `${parseInt(s.substr(0, 2), 16)}.${parseInt(
+        s.substr(2, 2),
+        16,
+      )}.${parseInt(s.substr(4, 2), 16)}.${parseInt(s.substr(6, 2), 16)}`;
+      return ip;
+    } catch (ex) {
+      throw malformedErr;
+    }
+  } else if (s.length === 16) {
+    try {
+      return `${hextoip(s.substr(0, 8))}/${ipprefixlen(s.substr(8))}`;
+    } catch (ex) {
+      throw malformedErr;
+    }
+  } else if (s.length === 32) {
+    return hextoipv6(s);
+  } else if (s.length === 64) {
+    try {
+      return `${hextoipv6(s.substr(0, 32))}/${ipprefixlen(s.substr(32))}`;
+    } catch (ex) {
+      throw malformedErr;
+    }
+  } else {
+    return s;
+  }
+}
+
+/**
+ * convert IPv4/v6 addresss to a hexadecimal string
+ * @param sIn - IPv4/v6 address string
+ * @return hexadecimal string of IP address
+ * @see hextoip
+ * @see ipv6tohex
+ *
+ * @description
+ * This function converts IPv4 or IPv6 address string to
+ * a hexadecimal string of IPv4 or IPv6 address.
+ *
+ * @example
+ * iptohex("192.168.1.1") -> "c0a80101"
+ * iptohex("2001:db8::4") -> "871020010db8000000000000000000000004"
+ * iptohex("192.168.1.1/24") -> "c0a80101ffffff00"
+ * iptohex("2001:db8::/120") -> "871020010db8000000000000000000000000ffffffffffffffffffffffffffffffffff00"
+ * iptohex("zzz")) -> raise exception
+ */
+export function iptohex(sIn: string): string {
+  let s: string = sIn;
+  const malformedErr = new Error("malformed IP address");
+  s = s.toLowerCase();
+
+  if (!s.match(/^[0-9a-f.:/]+$/)) throw malformedErr;
+
+  if (s.match(/^[0-9.]+$/)) {
+    const a = s.split(".");
+    if (a.length !== 4) throw malformedErr;
+    let hex = "";
+    try {
+      for (let i = 0; i < 4; i++) {
+        const d = parseInt(a[i]);
+        hex += `0${d.toString(16)}`.slice(-2);
+      }
+      return hex;
+    } catch (ex) {
+      throw malformedErr;
+    }
+  } else if (s.match(/^[0-9.]+\/[0-9]+$/)) {
+    const aItem = s.split("/");
+    return iptohex(aItem[0]) + ipnetmask(parseInt(aItem[1]), 32);
+  } else if (s.match(/^[0-9a-f:]+$/) && s.indexOf(":") !== -1) {
+    return ipv6tohex(s);
+  } else if (s.match(/^[0-9a-f:]+\/[0-9]+$/) && s.indexOf(":") !== -1) {
+    const aItem = s.split("/");
+    return ipv6tohex(aItem[0]) + ipnetmask(parseInt(aItem[1]), 128);
+  } else {
+    throw malformedErr;
+  }
+}
+
+/*
+ * convert subnet mask hex to ip address prefix length<br/>
+ * @param hMask - hexadecimal string of ipv4/6 subnet mask (ex. "ffffff00" for v4 class C)
+ * @return ip address prefix length (ex. 24 for IPv4 class C)
+ */
+export function ipprefixlen(hMask: string): number {
+  const malformedErr = new Error("malformed mask");
+  let bMask: string;
+  try {
+    bMask = parseInt(hMask, 16).toString(2);
+  } catch (ex) {
+    throw malformedErr;
+  }
+  if (!bMask.match(/^1*0*$/)) throw malformedErr;
+  return bMask.replace(/0+$/, "").length;
+}
+
+/*
+ * convert ip prefix length to net mask octets<br/>
+ * @param prefixlen - ip prefix length value (ex. 24 for IPv4 class C)
+ * @param len - ip address length (ex. 32 for IPv4 and 128 for IPv6)
+ * @return hexadecimal string of net mask octets
+ * @example
+ * ipnetmask(24, 32) -> "ffffff00"
+ * ipnetmask(120, 128) -> "ffffffffffffffffffffffffffffff00"
+ */
+export function ipnetmask(prefixlen: number, len: number): string {
+  if (len === 32 && prefixlen === 0) return "00000000"; // v4
+  if (len === 128 && prefixlen === 0) return "00000000000000000000000000000000"; // v6
+  const b =
+    Array(prefixlen + 1).join("1") + Array(len - prefixlen + 1).join("0");
+  return parseInt(b, 2).toString(16);
+}

package/src/conv_iso88591.mts

@@ -0,0 +1,63 @@
+import { hextoutf8, utf8tohex } from "./conv.mts";
+
+/**
+ * convert a hexadecimal ISO 8859-1 latin string to UTF-8 string
+ * @param h hexadecimal ISO 8859-1 latin string
+ * @return UTF-8 string
+ * @see {@link utf8toiso88591hex}
+ * @example
+ * iso88591hextoutf8("41a9fa") -> "A©ú"
+ */
+export function iso88591hextoutf8(h: string): string {
+  return hextoutf8(iso88591hextoutf8hex(h));
+}
+
+/**
+ * convert UTF-8 string to a hexadecimal ISO 8859-1 latin string
+ * @param s hexadecimal ISO 8859-1 latin string
+ * @return UTF-8 string
+ * @see {@link iso88591hextoutf8}
+ * @example
+ * utf8toiso88591hex("A©ú") -> "41a9fa"
+ */
+export function utf8toiso88591hex(s: string): string {
+  return utf8hextoiso88591hex(utf8tohex(s));
+}
+
+function iso88591hextoutf8hex(h: string): string {
+  const a = h.match(/.{1,2}/g);
+  if (a == null) return "";
+  const a2 = [];
+  for (let i = 0; i < a.length; i++) {
+    const di = parseInt(a[i], 16);
+    if (0xa1 <= di && di <= 0xbf) {
+      a2.push("c2");
+      a2.push(a[i]);
+    } else if (0xc0 <= di && di <= 0xff) {
+      a2.push("c3");
+      a2.push((di - 64).toString(16));
+    } else {
+      a2.push(a[i]);
+    }
+  }
+  return a2.join("");
+}
+
+function utf8hextoiso88591hex(h: string): string {
+  const a = h.match(/.{1,2}/g);
+  if (a == null) return "";
+  const a2 = [];
+  for (let i = 0; i < a.length; i++) {
+    if (a[i] === "c2") {
+      i++;
+      a2.push(a[i]);
+    } else if (a[i] === "c3") {
+      i++;
+      const di = parseInt(a[i], 16) + 64;
+      a2.push(di.toString(16));
+    } else {
+      a2.push(a[i]);
+    }
+  }
+  return a2.join("");
+}

package/src/conv_pem.mts

@@ -0,0 +1,160 @@
+import { b64tohex, hextob64 } from "./conv.mts";
+
+// === pem / hex ======================
+/**
+ * get PEM string from hexadecimal data and header string
+ * @param dataHex - hexadecimal string of PEM body
+ * @param pemHeader - PEM header string (ex. 'RSA PRIVATE KEY')
+ * @param separator - new line string
+ * @return PEM formatted string of input data
+ *
+ * @description
+ * This function converts a hexadecimal string to a PEM string with
+ * a specified header. Its line break will be CRLF("\r\n").
+ *
+ * @example
+ * hextopem('616161', 'RSA PRIVATE KEY') ->
+ * -----BEGIN PRIVATE KEY-----
+ * YWFh
+ * -----END PRIVATE KEY-----
+ */
+export function hextopem(
+  dataHex: string,
+  pemHeader: string,
+  separator = "\r\n",
+): string {
+  return `-----BEGIN ${pemHeader}-----${separator}${foldnl(
+    hextob64(dataHex),
+    64,
+  )}${separator}-----END ${pemHeader}-----${separator}`;
+}
+
+/**
+ * get hexacedimal string from PEM format data
+ * @param s - PEM formatted string
+ * @param sHead - PEM header string without BEGIN/END
+ * @return hexadecimal string data of PEM contents
+ *
+ * @description
+ * This static method gets a hexacedimal string of contents
+ * from PEM format data. You can explicitly specify PEM header
+ * by sHead argument.
+ * Any space characters such as white space or new line
+ * will be omitted.
+ *
+ * @example
+ * pemtohex("-----BEGIN PUBLIC KEY...") -> "3082..."
+ * pemtohex("-----BEGIN CERTIFICATE...", "CERTIFICATE") -> "3082..."
+ * pemtohex(" \r\n-----BEGIN DSA PRIVATE KEY...") -> "3082..."
+ * pemtohex("-----BEGIN EC PARAMETERS...----BEGIN EC PRIVATE KEY...." -> "3082..."
+ */
+export function pemtohex(s: string, sHead?: string): string {
+  return b64tohex(pemtob64(s, sHead));
+}
+
+/**
+ * get Base64 string from PEM format data
+ * @param pem - PEM formatted string
+ * @param sHead - PEM header string without BEGIN/END
+ * @return Base64 string
+ *
+ * @description
+ * This static method gets a Base64 string of contents
+ * from PEM format data.
+ *
+ * @example
+ * pemtob64("-----BEGIN CERTIFICATE...", "CERTIFICATE") -> "MIIBvTCC..."
+ * pemtob64("-----BEGIN CERTIFICATE...") -> "MIIBvTCC..."
+ */
+export function pemtob64(pem: string, sHead?: string): string {
+  let s: string = pem;
+  if (s.indexOf("-----BEGIN ") === -1) throw new Error("can't find PEM header");
+
+  if (sHead !== undefined) {
+    s = s.replace(new RegExp(`^[^-]*-----BEGIN ${sHead}-----`), "");
+    s = s.replace(new RegExp(`-----END ${sHead}-----[^-]*$`), "");
+  } else {
+    s = s.replace(/^[^-]*-----BEGIN [^-]+-----/, "");
+    s = s.replace(/-----END [^-]+-----[^-]*$/, "");
+  }
+  return s.replace(/\s+/g, "");
+}
+
+// === others =========================
+
+/**
+ * get PEM string from Base64 string
+ * @param b64 - Base64 string of PEM body
+ * @param pemHeader - PEM header string (ex. 'RSA PRIVATE KEY')
+ * @param separator - new line string
+ * @return PEM formatted string of input data
+ *
+ * @description
+ * This function converts a Base64 string to a PEM string with
+ * a specified header. Its line break will be CRLF("\r\n").
+ *
+ * @example
+ * b64topem('YWFh', 'RSA PRIVATE KEY') ->
+ * -----BEGIN PRIVATE KEY-----
+ * YWFh
+ * -----END PRIVATE KEY-----
+ */
+export function b64topem(
+  b64: string,
+  pemHeader: string,
+  separator = "\r\n",
+): string {
+  return `-----BEGIN ${pemHeader}-----${separator}${foldnl(
+    b64,
+    64,
+    separator,
+  )}${separator}-----END ${pemHeader}-----${separator}`;
+}
+
+/**
+ * convert a Base64 encoded string with new lines to a hexadecimal string
+ * @param s - Base64 encoded string with new lines
+ * @return hexadecimal string
+ *
+ * @description
+ * This function converts from a Base64 encoded
+ * string with new lines to a hexadecimal string.
+ * This is useful to handle PEM encoded file.
+ * This function removes any non-Base64 characters (i.e. not 0-9,A-Z,a-z,\,+,=)
+ * including new line.
+ *
+ * @example
+ * hextob64nl(
+ * "MTIzNDU2Nzg5MDEyMzQ1Njc4OTAxMjM0NTY3ODkwMTIzNDU2Nzg5MDEyMzQ1Njc4\r\n" +
+ * "OTAxMjM0NTY3ODkwCg==\r\n")
+ * ->
+ * "123456789012345678901234567890123456789012345678901234567890"
+ */
+export function b64nltohex(s: string): string {
+  const b64 = s.replace(/[^0-9A-Za-z\/+=]*/g, "");
+  const hex = b64tohex(b64);
+  return hex;
+}
+
+/**
+ * wrap string with new lines to fit in specified width
+ * @param sIn - string
+ * @param n - width
+ * @param separator - line separator
+ * @return wrapped string with new lines
+ *
+ * @description
+ * This function wrap a string with new lines to fit in specified width.
+ *
+ * @example
+ * foldnl("1234567890", 6)
+ * ->
+ * 123456
+ * 7890
+ */
+export function foldnl(sIn: string, n: number, separator = "\r\n"): string {
+  let s: string = sIn;
+  s = s.replace(new RegExp(`(.{${n}})`, "g"), `$1${separator}`);
+  s = s.replace(/\s+$/, "");
+  return s;
+}