ver 0.3.5

Author: Srabutdotcom

deno.json

@@ -1,6 +1,6 @@
 {
   "name": "@tls/enum",
-  "version": "0.3.4",
+  "version": "0.3.5",
   "exports": "./src/mod.ts",
   "publish": {
     "exclude": ["dist/"]
@@ -16,8 +16,6 @@
     "@noble/curves": "npm:@noble/curves@^1.7.0",
     "@peculiar/x509": "npm:@peculiar/x509@^1.12.3",
     "@std/assert": "jsr:@std/assert@^1.0.2",
-    "@tls/extension": "jsr:@tls/extension@^0.2.1",
-    "@tls/record": "jsr:@tls/record@^0.0.7",
     "@tls/struct": "jsr:@tls/struct@^0.3.1"
   }
 }

src/certificatetype.js

@@ -2,8 +2,9 @@
 // @ts-self-types="../type/certificatetype.d.ts"
 
 import { Enum } from "./enum.js";
-import { Constrained, Struct, Uint24, Uint8, Uint16, Extension } from "./dep.ts"
+import { Constrained, Struct, Uint24, Uint8, Uint16 } from "./dep.ts"
 import { x509 } from "./dep.ts";
+import { Extension } from "./extensiontype.js"
 
 /**
  * Supported groups - @see https://datatracker.ietf.org/doc/html/rfc8446#section-4.2.7.

src/contentype.js

@@ -1,7 +1,7 @@
 // deno-lint-ignore-file no-slow-types
 // @ts-self-types="../type/contentype.d.ts"
 
-import { Uint8, TLSPlaintext } from "./dep.ts";
+import { Uint8, Uint16, Struct } from "./dep.ts";
 import { Enum } from "./enum.js";
 import { Version } from "./version.js";
 
@@ -45,4 +45,31 @@ export class ContentType extends Enum {
    }
 }
 
+export class TLSPlaintext extends Uint8Array {
+   static from(array){
+      let offset = 0;
+      const copy = Uint8Array.from(array);
+      const type = ContentType.from(copy);offset+=1;
+      const version = Version.from(copy.subarray(offset));offset+=2;
+      const lengthOf = Uint16.from(copy.subarray(offset)).value; offset+=2;
+      const fragment = copy.subarray(offset, offset+lengthOf)
+      return new TLSPlaintext(type, version, fragment)
+   }
+   static createFrom(type, version, fragment){ return new TLSPlaintext(type, version, fragment)}
+   constructor(type, version, fragment){
+      const struct = new Struct(
+         type.Uint8,
+         version.protocolVersion(),
+         Uint16.fromValue(fragment.length),
+         fragment
+      )
+      super(struct)
+
+      this.type = type;
+      this.version = version;
+      this.fragment = fragment
+      this.items = struct.items
+   }
+}
+
 //npx -p typescript tsc ./src/contentype.js --declaration --allowJs --emitDeclarationOnly --lib ESNext --outDir ./dist

src/dep.ts

@@ -1,13 +1,10 @@
-export { Struct, Constrained, Byte } from "@tls/struct"
-export { Uint8, Uint16, Uint24, Uint32 } from "@tls/struct"
-export { Extension, KeyExchange, KeyShareEntry } from "@tls/extension"
+export * from "@tls/struct"
 export { p256 } from '@noble/curves/p256'
 export { p384 } from '@noble/curves/p384'
 export { p521 } from '@noble/curves/p521'
 export { x25519 } from '@noble/curves/ed25519'
 export { x448 } from '@noble/curves/ed448'
 export * as utils from "@noble/curves/abstract/utils"
-export { TLSPlaintext } from "@tls/record"
 export { HexaDecimal } from "@tls/struct"
 export * as x509 from "@peculiar/x509"
 

src/extensiontype.js

@@ -1,7 +1,7 @@
 // deno-lint-ignore-file no-slow-types
 // @ts-self-types="../type/extensiontype.d.ts"
 
-import { Uint16, Extension } from "./dep.ts";
+import { Uint16, Constrained, Struct } from "./dep.ts";
 import { Enum } from "./enum.js";
 
 /**
@@ -216,7 +216,36 @@ export class ExtensionType extends Enum {
    extension(extension_data){return new Extension(this, extension_data)}
 }
 
+export class ExtensionData extends Constrained {
+   opaque
+   static fromOpaque(opaque) { return new ExtensionData(opaque) }
+   static from(array) {
+      const copy = Uint8Array.from(array);
+      const lengthOf = Uint16.from(copy).value; // First 2 bytes represent the length
+      const extensionData = copy.subarray(2, lengthOf + 2);
+      return new ExtensionData(extensionData);
+   }
+   constructor(opaque) {
+      super(0, 2 ** 16 - 1, opaque)
+      this.opaque = opaque
+   }
+}
 
+export class Extension extends Struct {
+   extension_type
+   extension_data
+   constructor(extension_type, extension_data) {
+      super(extension_type.Uint16, ExtensionData.fromOpaque(extension_data))
+      this.extension_type = extension_type;
+      this.extension_data = extension_data
+   }
+   static from(array) {
+      const copy = Uint8Array.from(array);
+      const extension_type = ExtensionType.from(copy.subarray(0, 2))
+      const extension_data = ExtensionData.from(copy.subarray(2));
+      return new Extension(extension_type, extension_data.opaque)
+   }
+}
 
 
 

src/namedgroup.js

@@ -1,7 +1,7 @@
 // deno-lint-ignore-file no-slow-types
 // @ts-self-types="../type/namedgroup.d.ts"
 
-import { p256, p384, p521, x25519, x448, Uint16, KeyExchange, KeyShareEntry } from "./dep.ts";
+import { p256, p384, p521, x25519, x448, Uint16, Constrained, Struct } from "./dep.ts";
 import { Enum } from "./enum.js";
 
 /**
@@ -122,7 +122,44 @@ export class NamedGroup extends Enum {
    }
 }
 
+/**
+ * Represents a key exchange mechanism.
+ */
+export class KeyExchange extends Constrained {
+
+   static fromKey(octet) { return new KeyExchange(octet); }
+
+   static from(array) {
+      const copy = Uint8Array.from(array);
+      const lengthOf = Uint16.from(copy.subarray(0, 2)).value;
+      const octet = copy.subarray(2, 2 + lengthOf);
+      return new KeyExchange(octet);
+   }
+
+   constructor(octet) {
+      super(1, 65535, octet);
+      this.key_exchange = octet;
+   }
+}
 
+/**
+ * Represents a key share entry.
+ */
+export class KeyShareEntry extends Struct {
+   
+   static from(array) {
+      const copy = Uint8Array.from(array);
+      const group = NamedGroup.from(copy.subarray(0, 2));
+      const key_exchange = KeyExchange.from(copy.subarray(2));
+      return new KeyShareEntry(group, key_exchange);
+   }
+
+   constructor(group, key_exchange) {
+      super(group.Uint16, key_exchange);
+      this.group = group;
+      this.key_exchange = key_exchange.key_exchange;
+   }
+}
 
 
 

test/version_test.js

@@ -62,3 +62,4 @@ Deno.test("ProtocolVersion Class - Constructor", () => {
 });
 
 const protocolVersion = ProtocolVersion.fromVersion(Version.TLS12);
+

type/certificatetype.d.ts

@@ -1,5 +1,5 @@
 import { Enum } from "../src/enum.js";
-import { Constrained } from "../src/dep.ts";
+import { Constrained, x509 } from "../src/dep.ts";
 
 /**
  * Represents TLS Certificate Types.
@@ -35,24 +35,35 @@ export class CertificateType extends Enum {
  */
 export class CertificateEntry extends Uint8Array {
   /**
-   * Parses an array to create a `CertificateEntry`.
-   * @param {Uint8Array} array - The array to parse.
-   * @returns {CertificateEntry} The parsed certificate entry.
+   * The opaque certificate data.
    */
-  static from(array: Uint8Array): CertificateEntry;
+  readonly opaque: Uint8Array;
 
   /**
-   * Constructs a `CertificateEntry`.
-   * @param {Uint8Array} opaque - The certificate data.
-   * @param {...Uint8Array} extension - The certificate extensions.
+   * The extensions associated with the certificate.
    */
-  constructor(opaque: Uint8Array, ...extension: Uint8Array[]);
+  readonly extension: any[];
 
-  /** The certificate data. */
-  opaque: Uint8Array;
+  /**
+   * Parsed X.509 certificate.
+   */
+  readonly x509: x509.X509Certificate;
 
-  /** The certificate extensions. */
-  extension: Uint8Array[];
+  /**
+   * Creates a `CertificateEntry` instance from an array-like object.
+   *
+   * @param {Uint8Array} array - The source array-like object to create the certificate entry from.
+   * @returns {CertificateEntry} - A new `CertificateEntry` instance.
+   */
+  static from(array: Uint8Array): CertificateEntry;
+
+  /**
+   * Constructs a `CertificateEntry` instance.
+   *
+   * @param {Uint8Array} opaque - The opaque certificate data.
+   * @param {...Uint8Array} extension - The extensions associated with the certificate.
+   */
+  constructor(opaque: Uint8Array, ...extension: Uint8Array[]);
 }
 
 /**

type/contentype.d.ts

@@ -1,4 +1,4 @@
-import { Uint8, TLSPlaintext } from "../src/dep.ts";
+import { Uint8 } from "../src/dep.ts";
 import { Enum } from "../src/enum.js";
 import { Version } from "../src/version.js";
 
@@ -25,33 +25,93 @@ export class ContentType extends Enum {
 
   /**
    * Checks the given octet and returns a valid ContentType instance.
-   * 
+   *
    * @param {Uint8Array} octet - A single-octet Uint8Array to evaluate.
    * @returns {ContentType} The corresponding ContentType or throws an error if invalid.
    */
   static from(octet: Uint8Array): ContentType;
 
   /**
    * Returns the Uint8 representation of the ContentType.
-   * 
+   *
    * @readonly
    * @type {Uint8}
    */
   get Uint8(): Uint8;
 
   /**
    * Returns the bit size of the ContentType.
-   * 
+   *
    * @readonly
    * @type {8}
    */
   get bit(): 8;
 
   /**
    * Creates a `TLSPlaintext` instance using the ContentType, TLS version, and fragment.
-   * 
+   *
    * @param {Uint8Array} fragment - The plaintext fragment to include.
    * @returns {TLSPlaintext} A TLSPlaintext object created with the specified parameters.
    */
   tlsPlainText(fragment: Uint8Array): TLSPlaintext;
 }
+
+/**
+ * Represents a TLS plaintext record as a specialized `Uint8Array`.
+ */
+export class TLSPlaintext extends Uint8Array {
+  /**
+   * Parses a given array into a `TLSPlaintext` instance.
+   *
+   * @param {Uint8Array} array - The input byte array.
+   * @returns {TLSPlaintext} A new `TLSPlaintext` instance created from the array.
+   */
+  static from(array: Uint8Array): TLSPlaintext;
+
+  /**
+   * Creates a `TLSPlaintext` instance from specific type, version, and fragment.
+   *
+   * @param {ContentType} type - The content type of the plaintext.
+   * @param {Version} version - The protocol version.
+   * @param {Uint8Array} fragment - The fragment data.
+   * @returns {TLSPlaintext} A new `TLSPlaintext` instance.
+   */
+  static createFrom(
+    type: ContentType,
+    version: Version,
+    fragment: Uint8Array,
+  ): TLSPlaintext;
+
+  /**
+   * Constructs a new `TLSPlaintext` instance.
+   *
+   * @param {ContentType} type - The content type.
+   * @param {Version} version - The protocol version.
+   * @param {Uint8Array} fragment - The fragment data.
+   */
+  constructor(type: ContentType, version: Version, fragment: Uint8Array);
+
+  /**
+   * The content type of the TLS plaintext record.
+   * @type {ContentType}
+   */
+  readonly type: ContentType;
+
+  /**
+   * The protocol version of the TLS plaintext record.
+   * @type {Version}
+   */
+  readonly version: Version;
+
+  /**
+   * The fragment data of the TLS plaintext record.
+   * @type {Uint8Array}
+   */
+  readonly fragment: Uint8Array;
+
+  /**
+   * The underlying `Struct` instance representing the TLS plaintext record.
+   * @type {[Uint8Array,Uint8Array,Uint8Array]}
+   */
+  readonly items: [Uint8Array, Uint8Array, Uint8Array];
+}