src/lib/pgp/sign.ts


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

import type {
  KeyID,
  Signature as InnerSignature,
  SignaturePacket,
} from "openpgp";
import { defined, identity } from "../../utils/anonymous.ts";
import { type MaybeIterable, surelyIterable } from "../../utils/iterator.ts";

export class Signature {
  private signature!: InnerSignature;
  #packets!: Map<string, Packet[]>;

  constructor(signature: InnerSignature) {
    this.signature = signature;
    this.#packets = new Map();
    for (const packet of this.signature.packets) {
      const key = packet.issuerKeyID.bytes;
      const keyPackets = this.#packets.get(key);
      if (keyPackets !== undefined) {
        keyPackets.push(new Packet(packet));
      } else {
        this.#packets.set(key, [new Packet(packet)]);
      }
    }
  }

  getPackets(key?: MaybeIterable<KeyID>): Packet[] {
    key ??= this.signingKeyIDs;
    // deno-lint-ignore no-undef
    const iterator = Iterator.from(surelyIterable(key));
    return iterator.map((key) => this.#packets.get(key.bytes)).filter(defined)
      .flatMap(identity).toArray();
  }

  get signingKeyIDs(): ReturnType<
    InstanceType<typeof InnerSignature>["getSigningKeyIDs"]
  > {
    return this.signature.getSigningKeyIDs();
  }

  get inner(): InnerSignature {
    return this.signature;
  }
}

export class Packet {
  private packet!: SignaturePacket;

  constructor(packet: SignaturePacket) {
    this.packet = packet;
  }

  get signersUserID(): SignaturePacket["signersUserID"] {
    return this.packet.signersUserID;
  }

  get issuerKeyID(): SignaturePacket["issuerKeyID"] {
    return this.packet.issuerKeyID;
  }

  get issuerFingerprint(): SignaturePacket["issuerFingerprint"] {
    return this.packet.issuerFingerprint;
  }

  get created(): SignaturePacket["created"] {
    return this.packet.created;
  }

  get signatureType(): SignaturePacket["signatureType"] {
    return this.packet.signatureType;
  }

  get trustLevel(): SignaturePacket["trustLevel"] {
    return this.packet.trustLevel;
  }
  get trustAmount(): SignaturePacket["trustAmount"] {
    return this.packet.trustAmount;
  }

  get inner(): SignaturePacket {
    return this.packet;
  }
}