ctes-models-ts 0.0.1

package/README.md

@@ -0,0 +1,9 @@
+# Ciphertext Ecosystem TypeScript Models
+
+This dependency defines the models for the ciphertext ecosystem, used for building tools that will help solve unsolved ciphers.
+
+## Generating the model
+
+Requires installing the [Protoc CLI](https://protobuf.dev/installation/).
+
+Run `npm install` then `npm run generate` to generate the latest version of the model.

package/generate.sh

@@ -0,0 +1,11 @@
+git clone git@github.com:irebased/CiphertextEcosystemProtobuf.git
+cd CiphertextEcosystemProtobuf
+protoc \
+  --plugin=protoc-gen-ts_proto=../node_modules/.bin/protoc-gen-ts_proto \
+  --ts_proto_out=../ \
+  --ts_proto_opt=esModuleInterop=true,forceLong=string,useOptionals=true \
+  ./model/ciphertext.proto
+cd ..
+mv model/ciphertext.ts index.ts
+rm -rf model
+rm -rf CiphertextEcosystemProtobuf

package/index.ts

@@ -0,0 +1,394 @@
+// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
+// versions:
+//   protoc-gen-ts_proto  v2.11.0
+//   protoc               v6.33.4
+// source: model/ciphertext.proto
+
+/* eslint-disable */
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+
+export const protobufPackage = "model.ciphertext";
+
+/**
+ * Enum for representing encoding types.
+ * Can be extended for additional encoding support.
+ */
+export enum Encoding {
+  ENCODING_UNSPECIFIED = 0,
+  BASE_CONVERSION = 1,
+  ASCII = 2,
+  LATIN1 = 3,
+  UTF8 = 4,
+  UTF16 = 5,
+  UTF32 = 6,
+  UNRECOGNIZED = -1,
+}
+
+export function encodingFromJSON(object: any): Encoding {
+  switch (object) {
+    case 0:
+    case "ENCODING_UNSPECIFIED":
+      return Encoding.ENCODING_UNSPECIFIED;
+    case 1:
+    case "BASE_CONVERSION":
+      return Encoding.BASE_CONVERSION;
+    case 2:
+    case "ASCII":
+      return Encoding.ASCII;
+    case 3:
+    case "LATIN1":
+      return Encoding.LATIN1;
+    case 4:
+    case "UTF8":
+      return Encoding.UTF8;
+    case 5:
+    case "UTF16":
+      return Encoding.UTF16;
+    case 6:
+    case "UTF32":
+      return Encoding.UTF32;
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return Encoding.UNRECOGNIZED;
+  }
+}
+
+export function encodingToJSON(object: Encoding): string {
+  switch (object) {
+    case Encoding.ENCODING_UNSPECIFIED:
+      return "ENCODING_UNSPECIFIED";
+    case Encoding.BASE_CONVERSION:
+      return "BASE_CONVERSION";
+    case Encoding.ASCII:
+      return "ASCII";
+    case Encoding.LATIN1:
+      return "LATIN1";
+    case Encoding.UTF8:
+      return "UTF8";
+    case Encoding.UTF16:
+      return "UTF16";
+    case Encoding.UTF32:
+      return "UTF32";
+    case Encoding.UNRECOGNIZED:
+    default:
+      return "UNRECOGNIZED";
+  }
+}
+
+/** Represents a ciphertext input and its metadata. */
+export interface Ciphertext {
+  /**
+   * The ciphertext must always be transmitted in binary format.
+   * If the ciphertext is encoded, please decode it to a bitstream first.
+   */
+  bytes: Uint8Array;
+  metadata?: CiphertextMetadata | undefined;
+}
+
+/**
+ * Metadata associated with the ciphertext.
+ * This structure is designed to be extensible.
+ */
+export interface CiphertextMetadata {
+  /**
+   * Generic type tagging so downstream tools can handle custom types of data,
+   * e.g. "Semaphore" for tools designed to interface with semaphore ciphers.
+   */
+  type: string;
+  /** Metadata about how the bytes should be encoded. */
+  encoding?: EncodingMetadata | undefined;
+}
+
+/** Metadata about how the bytes should be encoded. */
+export interface EncodingMetadata {
+  /** How a given ciphertext blob should be encoded. */
+  encoding: Encoding;
+  /**
+   * If the Encoding is BASE_CONVERSION, the base will specify which base to convert to;
+   * e.g., 2 for binary, 8 for octal, 10 for decimal, 16 for hexadecimal, 64 for base64.
+   */
+  base: number;
+}
+
+function createBaseCiphertext(): Ciphertext {
+  return { bytes: new Uint8Array(0), metadata: undefined };
+}
+
+export const Ciphertext: MessageFns<Ciphertext> = {
+  encode(message: Ciphertext, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.bytes.length !== 0) {
+      writer.uint32(10).bytes(message.bytes);
+    }
+    if (message.metadata !== undefined) {
+      CiphertextMetadata.encode(message.metadata, writer.uint32(18).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): Ciphertext {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseCiphertext();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.bytes = reader.bytes();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.metadata = CiphertextMetadata.decode(reader, reader.uint32());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): Ciphertext {
+    return {
+      bytes: isSet(object.bytes) ? bytesFromBase64(object.bytes) : new Uint8Array(0),
+      metadata: isSet(object.metadata) ? CiphertextMetadata.fromJSON(object.metadata) : undefined,
+    };
+  },
+
+  toJSON(message: Ciphertext): unknown {
+    const obj: any = {};
+    if (message.bytes.length !== 0) {
+      obj.bytes = base64FromBytes(message.bytes);
+    }
+    if (message.metadata !== undefined) {
+      obj.metadata = CiphertextMetadata.toJSON(message.metadata);
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<Ciphertext>, I>>(base?: I): Ciphertext {
+    return Ciphertext.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<Ciphertext>, I>>(object: I): Ciphertext {
+    const message = createBaseCiphertext();
+    message.bytes = object.bytes ?? new Uint8Array(0);
+    message.metadata = (object.metadata !== undefined && object.metadata !== null)
+      ? CiphertextMetadata.fromPartial(object.metadata)
+      : undefined;
+    return message;
+  },
+};
+
+function createBaseCiphertextMetadata(): CiphertextMetadata {
+  return { type: "", encoding: undefined };
+}
+
+export const CiphertextMetadata: MessageFns<CiphertextMetadata> = {
+  encode(message: CiphertextMetadata, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.type !== "") {
+      writer.uint32(10).string(message.type);
+    }
+    if (message.encoding !== undefined) {
+      EncodingMetadata.encode(message.encoding, writer.uint32(18).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): CiphertextMetadata {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseCiphertextMetadata();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.type = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.encoding = EncodingMetadata.decode(reader, reader.uint32());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): CiphertextMetadata {
+    return {
+      type: isSet(object.type) ? globalThis.String(object.type) : "",
+      encoding: isSet(object.encoding) ? EncodingMetadata.fromJSON(object.encoding) : undefined,
+    };
+  },
+
+  toJSON(message: CiphertextMetadata): unknown {
+    const obj: any = {};
+    if (message.type !== "") {
+      obj.type = message.type;
+    }
+    if (message.encoding !== undefined) {
+      obj.encoding = EncodingMetadata.toJSON(message.encoding);
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<CiphertextMetadata>, I>>(base?: I): CiphertextMetadata {
+    return CiphertextMetadata.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<CiphertextMetadata>, I>>(object: I): CiphertextMetadata {
+    const message = createBaseCiphertextMetadata();
+    message.type = object.type ?? "";
+    message.encoding = (object.encoding !== undefined && object.encoding !== null)
+      ? EncodingMetadata.fromPartial(object.encoding)
+      : undefined;
+    return message;
+  },
+};
+
+function createBaseEncodingMetadata(): EncodingMetadata {
+  return { encoding: 0, base: 0 };
+}
+
+export const EncodingMetadata: MessageFns<EncodingMetadata> = {
+  encode(message: EncodingMetadata, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.encoding !== 0) {
+      writer.uint32(8).int32(message.encoding);
+    }
+    if (message.base !== 0) {
+      writer.uint32(16).int32(message.base);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): EncodingMetadata {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseEncodingMetadata();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 8) {
+            break;
+          }
+
+          message.encoding = reader.int32() as any;
+          continue;
+        }
+        case 2: {
+          if (tag !== 16) {
+            break;
+          }
+
+          message.base = reader.int32();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): EncodingMetadata {
+    return {
+      encoding: isSet(object.encoding) ? encodingFromJSON(object.encoding) : 0,
+      base: isSet(object.base) ? globalThis.Number(object.base) : 0,
+    };
+  },
+
+  toJSON(message: EncodingMetadata): unknown {
+    const obj: any = {};
+    if (message.encoding !== 0) {
+      obj.encoding = encodingToJSON(message.encoding);
+    }
+    if (message.base !== 0) {
+      obj.base = Math.round(message.base);
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<EncodingMetadata>, I>>(base?: I): EncodingMetadata {
+    return EncodingMetadata.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<EncodingMetadata>, I>>(object: I): EncodingMetadata {
+    const message = createBaseEncodingMetadata();
+    message.encoding = object.encoding ?? 0;
+    message.base = object.base ?? 0;
+    return message;
+  },
+};
+
+function bytesFromBase64(b64: string): Uint8Array {
+  if ((globalThis as any).Buffer) {
+    return Uint8Array.from(globalThis.Buffer.from(b64, "base64"));
+  } else {
+    const bin = globalThis.atob(b64);
+    const arr = new Uint8Array(bin.length);
+    for (let i = 0; i < bin.length; ++i) {
+      arr[i] = bin.charCodeAt(i);
+    }
+    return arr;
+  }
+}
+
+function base64FromBytes(arr: Uint8Array): string {
+  if ((globalThis as any).Buffer) {
+    return globalThis.Buffer.from(arr).toString("base64");
+  } else {
+    const bin: string[] = [];
+    arr.forEach((byte) => {
+      bin.push(globalThis.String.fromCharCode(byte));
+    });
+    return globalThis.btoa(bin.join(""));
+  }
+}
+
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+
+export type DeepPartial<T> = T extends Builtin ? T
+  : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>>
+  : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>>
+  : T extends {} ? { [K in keyof T]?: DeepPartial<T[K]> }
+  : Partial<T>;
+
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+export type Exact<P, I extends P> = P extends Builtin ? P
+  : P & { [K in keyof P]: Exact<P[K], I[K]> } & { [K in Exclude<keyof I, KeysOfUnion<P>>]: never };
+
+function isSet(value: any): boolean {
+  return value !== null && value !== undefined;
+}
+
+export interface MessageFns<T> {
+  encode(message: T, writer?: BinaryWriter): BinaryWriter;
+  decode(input: BinaryReader | Uint8Array, length?: number): T;
+  fromJSON(object: any): T;
+  toJSON(message: T): unknown;
+  create<I extends Exact<DeepPartial<T>, I>>(base?: I): T;
+  fromPartial<I extends Exact<DeepPartial<T>, I>>(object: I): T;
+}

package/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "ctes-models-ts",
+  "version": "0.0.1",
+  "description": "Ciphertext Ecosystem models.",
+  "author": "irebased <rebased.again@gmail.com>",
+  "license": "MIT",
+  "scripts": {
+    "generate": ". ./generate.sh"
+  },
+  "devDependencies": {
+    "ts-proto": "^2.11.0"
+  }
+}