add TLSInnerPlaintext and TLSChipertext

Author: Srabutdotcom

deno.json

@@ -1,6 +1,6 @@
 {
   "name": "@tls/enum",
-  "version": "0.3.8",
+  "version": "0.3.9",
   "exports": "./src/mod.ts",
   "publish": {
     "exclude": ["dist/"]
@@ -18,6 +18,6 @@
     "@peculiar/x509": "npm:@peculiar/x509@^1.12.3",
     "@std/assert": "jsr:@std/assert@^1.0.2",
     "@tls/crypto": "jsr:@tls/crypto@^0.0.9",
-    "@tls/struct": "jsr:@tls/struct@^0.3.1"
+    "@tls/struct": "jsr:@tls/struct@^0.3.2"
   }
 }

src/contentype.js

@@ -29,34 +29,42 @@ export class ContentType extends Enum {
       return ContentType.fromValue(octet[0]) ?? Error(`Unknown ${octet[0]} ContentType type`);
    }
 
-   get Uint8(){
+   get Uint8() {
       return Uint8.fromValue(+this)
    }
 
    /**return 8 */
    get bit() { return 8 }
 
-   tlsPlainText(fragment){
+   tlsPlainText(fragment) {
       return TLSPlaintext.createFrom(
          this,
          Version.TLS13,
          fragment
       )
    }
+
+   tlsInnerPlaintext(content, numZeros){
+      return new TLSInnerPlaintext(content, this, numZeros)
+   }
+
+   tlsCiphertext(encrypted_record){
+      return new TLSCiphertext(encrypted_record)
+   }
 }
 
 export class TLSPlaintext extends Uint8Array {
-   static from(array){
+   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)
+      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){
+   static createFrom(type, version, fragment) { return new TLSPlaintext(type, version, fragment) }
+   constructor(type, version, fragment) {
       const struct = new Struct(
          type.Uint8,
          version.protocolVersion(),
@@ -72,4 +80,42 @@ export class TLSPlaintext extends Uint8Array {
    }
 }
 
+export class TLSInnerPlaintext extends Uint8Array {
+   static from(array){
+      const copy = Uint8Array.from(array);
+      const lastNonZeroIndex = copy.reduceRight((li,v,i)=>(li===-1 && v!==0? i:li),-1);
+      const content = copy.slice(0, lastNonZeroIndex);
+      const type = ContentType.fromValue(copy[lastNonZeroIndex]);
+      const numZeros = copy.length - 1 - lastNonZeroIndex;
+      return new TLSInnerPlaintext(content, type, numZeros)
+   }
+   constructor(content, type, numZeros) {
+      const struct = new Uint8Array(content.length + 1 + numZeros);
+      struct.set(content, 0);
+      struct[content.length] = +type;
+      super(struct)
+   }
+}
+
+export class TLSCiphertext extends Uint8Array {
+   static from(array){
+      const copy = Uint8Array.from(array);
+      // NOTE should check contentType
+      // NOTE legacy version can be bypassed
+      const lengthOf = Uint16.from(copy.subarray(3));
+      const encrypted_record = copy.subarray(5, lengthOf+5);
+      return new TLSCiphertext(encrypted_record)
+   }
+   constructor(encrypted_record){
+      const struct = new Uint8Array(encrypted_record.length+5);
+      const lengthOf = Uint16.fromValue(encrypted_record.length);
+      struct[0] = 23; // always application data
+      struct[1] = 3; // major legacy version;
+      struct[2] = 3; // minor legacy verions = TLS v1.2
+      struct.set(lengthOf,3);
+      struct.set(encrypted_record, 5);
+      super(struct)    
+   }
+}
+
 //npx -p typescript tsc ./src/contentype.js --declaration --allowJs --emitDeclarationOnly --lib ESNext --outDir ./dist

type/contentype.d.ts

@@ -115,3 +115,47 @@ export class TLSPlaintext extends Uint8Array {
    */
   readonly items: [Uint8Array, Uint8Array, Uint8Array];
 }
+
+/**
+ * Represents a TLSInnerPlaintext structure in the TLS 1.3 protocol.
+ * This class extends `Uint8Array` to encapsulate TLSInnerPlaintext data.
+ */
+export class TLSInnerPlaintext extends Uint8Array {
+  /**
+   * Creates a TLSInnerPlaintext instance from a given array.
+   *
+   * @param {Uint8Array } array - The input array to parse.
+   * @returns {TLSInnerPlaintext} A new instance of TLSInnerPlaintext.
+   */
+  static from(array: Uint8Array): TLSInnerPlaintext;
+
+  /**
+   * Constructs a TLSInnerPlaintext structure.
+   *
+   * @param {Uint8Array} content - The content bytes.
+   * @param {ContentType} type - The content type as a `ContentType` instance.
+   * @param {number} numZeros - The number of zero bytes to pad.
+   */
+  constructor(content: Uint8Array, type: ContentType, numZeros: number);
+}
+
+/**
+ * Represents a TLSCiphertext structure in the TLS 1.3 protocol.
+ * This class extends `Uint8Array` to encapsulate TLSCiphertext data.
+ */
+export class TLSCiphertext extends Uint8Array {
+  /**
+   * Creates a TLSCiphertext instance from a given array.
+   *
+   * @param {Uint8Array } array - The input array to parse.
+   * @returns {TLSCiphertext} A new instance of TLSCiphertext.
+   */
+  static from(array: Uint8Array): TLSCiphertext;
+
+  /**
+   * Constructs a TLSCiphertext structure.
+   *
+   * @param {Uint8Array} encrypted_record - The encrypted record bytes.
+   */
+  constructor(encrypted_record: Uint8Array);
+}