signature algorithms

Author: hazae41

src/mods/binary/records/handshakes/client_hello/client_hello2.ts

@@ -1,9 +1,11 @@
 import { Binary } from "@hazae41/binary"
 import { Number16, Number8 } from "mods/binary/number.js"
 import { Random } from "mods/binary/random.js"
+import { Extension } from "mods/binary/records/handshakes/extensions/extension.js"
 import { Handshake } from "mods/binary/records/handshakes/handshake.js"
 import { ArrayVector, Vector, Vector16, Vector8 } from "mods/binary/vector.js"
 import { Cipher } from "mods/ciphers/cipher.js"
+import { SignatureAlgorithms } from "../extensions/signature_algorithms/signature_algorithms.js"
 
 export class ClientHello2 {
   readonly #class = ClientHello2
@@ -31,11 +33,14 @@ export class ClientHello2 {
     const version = 0x0303
     const random = Random.default()
 
-    const session_id = new (ArrayVector<Number8, Number8>(Number8, Number8))([])
-    const cipher_suites = new (Vector16<Number16>(Number16))(ciphers.map(it => it.id))
-    const compression_methods = new (Vector8<Number8>(Number8))([0])
+    const session_id = ArrayVector<Number8, Number8>(Number8, Number8).from([])
+    const cipher_suites = Vector16<Number16>(Number16).from(ciphers.map(it => it.id))
+    const compression_methods = Vector8<Number8>(Number8).from([0])
 
-    return new this(version, random, session_id, cipher_suites, compression_methods)
+    const signature_algorithms = SignatureAlgorithms.default().extension()
+    const extensions = ArrayVector<Number16, Extension>(Number16, Extension).from([signature_algorithms])
+
+    return new this(version, random, session_id, cipher_suites, compression_methods, extensions)
   }
 
   size() {

src/mods/binary/records/handshakes/client_hello/client_hello3.ts

@@ -1,3 +1,3 @@
 export * from "./client_hello2.js";
-export * from "./client_hello3.js";
+
 

src/mods/binary/records/handshakes/client_hello/index.ts

@@ -3,35 +3,36 @@ import { Number16 } from "mods/binary/number.js"
 import { AnyVector, Vector } from "mods/binary/vector.js"
 import { Writable } from "mods/binary/writable.js"
 
-export interface IExtension extends Writable {
-  type: number
-}
 
 export class Extension {
   readonly #class = Extension
 
+  static types = {
+    signature_algorithms: 13
+  } as const
+
   constructor(
-    readonly type: number,
-    readonly data: Vector<Number16>
+    readonly extension_type: number,
+    readonly extension_data: Vector<Number16>
   ) { }
 
-  static from(extension: IExtension) {
-    const data = new (AnyVector<Number16>(Number16))(extension)
+  static from(type: number, extension: Writable) {
+    const data = AnyVector<Number16, Writable>(Number16).from(extension)
 
-    return new this(extension.type, data)
+    return new this(type, data)
   }
 
   get class() {
     return this.#class
   }
 
   size() {
-    return 2 + this.data.size()
+    return 2 + this.extension_data.size()
   }
 
   write(binary: Binary) {
-    binary.writeUint16(this.type)
-    this.data.write(binary)
+    binary.writeUint16(this.extension_type)
+    this.extension_data.write(binary)
   }
 
   static read(binary: Binary): Extension {

src/mods/binary/records/handshakes/extensions/extension.ts

@@ -1,2 +1,3 @@
 export * from "./extension.js";
-export * from "./supported_versions/index.js";
+export * from "./signature_algorithms/signature_algorithms.js";
+

src/mods/binary/records/handshakes/extensions/index.ts

@@ -0,0 +1,46 @@
+import { Binary } from "@hazae41/binary";
+import { Number16 } from "mods/binary/number.js";
+import { Extension } from "mods/binary/records/handshakes/extensions/extension.js";
+import { SignatureAndHashAlgorithm } from "mods/binary/signature.js";
+import { ArrayVector } from "mods/binary/vector.js";
+
+export class SignatureAlgorithms {
+  readonly #class = SignatureAlgorithms
+
+  static type = Extension.types.signature_algorithms
+
+  constructor(
+    readonly supported_signature_algorithms: ArrayVector<Number16, SignatureAndHashAlgorithm>
+  ) { }
+
+  static default() {
+    const { rsaWithSha256 } = SignatureAndHashAlgorithm.instances
+
+    const supported_signature_algorithms =
+      ArrayVector<Number16, SignatureAndHashAlgorithm>(
+        Number16, SignatureAndHashAlgorithm
+      ).from([rsaWithSha256])
+
+    return new this(supported_signature_algorithms)
+  }
+
+  get class() {
+    return this.#class
+  }
+
+  get type() {
+    return this.#class.type
+  }
+
+  size() {
+    return this.supported_signature_algorithms.size()
+  }
+
+  write(binary: Binary) {
+    this.supported_signature_algorithms.write(binary)
+  }
+
+  extension() {
+    return Extension.from(this.#class.type, this)
+  }
+}

src/mods/binary/records/handshakes/extensions/signature_algorithms/signature_algorithms.ts

@@ -5,15 +5,25 @@ import { BytesVector, Vector } from "mods/binary/vector.js";
 export class HashAlgorithm {
   readonly #class = HashAlgorithm
 
-  static types = {
+  static readonly types = {
     none: 0,
     md5: 1,
     sha1: 2,
     sha224: 3,
     sha256: 4,
     sha384: 5,
     sha512: 6,
-  }
+  } as const
+
+  static readonly instances = {
+    none: new this(this.types.none),
+    md5: new this(this.types.md5),
+    sha1: new this(this.types.sha1),
+    sha224: new this(this.types.sha224),
+    sha256: new this(this.types.sha256),
+    sha384: new this(this.types.sha384),
+    sha512: new this(this.types.sha512)
+  } as const
 
   constructor(
     readonly type: number
@@ -39,12 +49,19 @@ export class HashAlgorithm {
 export class SignatureAlgorithm {
   readonly #class = SignatureAlgorithm
 
-  static types = {
+  static readonly types = {
     anonymous: 0,
     rsa: 1,
     dsa: 2,
     ecdsa: 3
-  }
+  } as const
+
+  static readonly instances = {
+    anonymous: new this(this.types.anonymous),
+    rsa: new this(this.types.rsa),
+    dsa: new this(this.types.dsa),
+    ecdsa: new this(this.types.ecdsa)
+  } as const
 
   constructor(
     readonly type: number
@@ -70,6 +87,10 @@ export class SignatureAlgorithm {
 export class SignatureAndHashAlgorithm {
   readonly #class = SignatureAndHashAlgorithm
 
+  static readonly instances = {
+    rsaWithSha256: new this(HashAlgorithm.instances.sha256, SignatureAlgorithm.instances.rsa)
+  } as const
+
   constructor(
     readonly hash: HashAlgorithm,
     readonly signature: SignatureAlgorithm