Debian Codegraph @

crypto/rsa/pkcs1.ha

raw
1 // SPDX-License-Identifier: MPL-2.0
2 // (c) Hare authors <https://harelang.org>
3
4 use crypto::math;
5 use crypto::sha1;
6 use crypto::sha256;
7 use crypto::sha512;
8 use errors;
9
10 // Supported hash algorithms for [[pkcs1_sign]] and [[pkcs1_verify]].
11 export type pkcs1_hashalgo = enum {
12 SHA1,
13 // SHA224, We don't have this one yet
14 SHA256,
15 SHA384,
16 SHA512,
17 SHA512_224,
18 SHA512_256,
19 };
20
21 const OID_SHA1: [_]u8 = [
22 0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x0e, 0x03, 0x02,
23 0x1a, 0x05, 0x00, 0x04, 0x14,
24 ];
25
26 const OID_SHA224: [_]u8 = [
27 0x30, 0x2d, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86, 0x48, 0x01,
28 0x65, 0x03, 0x04, 0x02, 0x04, 0x05, 0x00, 0x04, 0x1c,
29 ];
30
31 const OID_SHA256: [_]u8 = [
32 0x30, 0x31, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86, 0x48, 0x01,
33 0x65, 0x03, 0x04, 0x02, 0x01, 0x05, 0x00, 0x04, 0x20,
34 ];
35
36 const OID_SHA384: [_]u8 = [
37 0x30, 0x41, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86, 0x48, 0x01,
38 0x65, 0x03, 0x04, 0x02, 0x02, 0x05, 0x00, 0x04, 0x30,
39 ];
40
41 const OID_SHA512: [_]u8 = [
42 0x30, 0x51, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86, 0x48, 0x01,
43 0x65, 0x03, 0x04, 0x02, 0x03, 0x05, 0x00, 0x04, 0x40,
44 ];
45
46 const OID_SHA512_224: [_]u8 = [
47 0x30, 0x2d, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86, 0x48, 0x01,
48 0x65, 0x03, 0x04, 0x02, 0x05, 0x05, 0x00, 0x04, 0x1c,
49 ];
50
51 const OID_SHA512_256: [_]u8 = [
52 0x30, 0x31, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86, 0x48, 0x01,
53 0x65, 0x03, 0x04, 0x02, 0x06, 0x05, 0x00, 0x04, 0x20,
54 ];
55
56 // Required buffer size for [[pkcs1_verify]].
57 export def PKCS1_VERIFYBUFSZ: size = PUBEXP_BUFSZ + (BITSZ / 8);
58
59 // Verifies a PKCS#1 v1.5 signature given a public key 'pubkey', the message
60 // hash 'msghash', the signature 'sig' and the hash algorithm 'algo'. 'algo'
61 // must reflect the hash algorithm 'sig' was created with.
62 //
63 // A temporary buffer 'buf' of size [[PKCS1_VERIFYBUFSZ]] must be provided.
64 export fn pkcs1_verify(
65 pubkey: []u8,
66 msghash: []u8,
67 sig: []u8,
68 algo: pkcs1_hashalgo,
69 buf: []u8
70 ) (void | error) = {
71 let pub = pubkey_params(pubkey);
72
73 let actualsig = buf[..len(sig)];
74 let pubbuf = buf[len(sig)..];
75
76 actualsig[..] = sig[..];
77 match (pubexp(&pub, actualsig, pubbuf)) {
78 case let e: error =>
79 return e;
80 case void => void;
81 };
82
83 let expectedsig = pubbuf[..len(sig)];
84 pkcs1_sig_encode(expectedsig, msghash, algo)?;
85
86 if (math::eqslice(expectedsig, actualsig) == 0) {
87 return badsig;
88 };
89 };
90
91 // Required buffer size for [[pkcs1_sign]].
92 export def PKCS1_SIGNBUFSZ: size = PRIVEXP_BUFSZ;
93
94 // Signs a message hash 'msghash' using the PKCS#1 V1.5 signature scheme. The
95 // signature will be written to 'sig' which must be in the the size of the
96 // modulus n (see [[privkey_nsize]]). 'algo' defines the hash algorithm
97 // 'msghash' was created with.
98 //
99 // A temporary buffer 'buf' of size [[PKCS1_SIGNBUFSZ]] must be provided.
100 export fn pkcs1_sign(
101 priv: []u8,
102 msghash: []u8,
103 sig: []u8,
104 algo: pkcs1_hashalgo,
105 buf: []u8
106 ) (void | error) = {
107 let priv = privkey_params(priv);
108 pkcs1_sig_encode(sig, msghash, algo)?;
109 privexp(&priv, sig, buf)?;
110 };
111
112 // Returns hash id and hash size for given 'algo'.
113 fn pkcs1_hashinfo(algo: pkcs1_hashalgo) (const []u8, size) = {
114 switch (algo) {
115 case pkcs1_hashalgo::SHA1 =>
116 return (OID_SHA1, sha1::SZ);
117 case pkcs1_hashalgo::SHA256 =>
118 return (OID_SHA256, sha256::SZ);
119 case pkcs1_hashalgo::SHA384 =>
120 return (OID_SHA384, sha512::SZ384);
121 case pkcs1_hashalgo::SHA512 =>
122 return (OID_SHA512, sha512::SZ);
123 case pkcs1_hashalgo::SHA512_224 =>
124 return (OID_SHA512_224, sha512::SZ224);
125 case pkcs1_hashalgo::SHA512_256 =>
126 return (OID_SHA512_256, sha512::SZ256);
127 case =>
128 abort("unreachable");
129 };
130 };
131
132 // Creates an unauthenticated signature of 'msg' and writes it into 'sig' using
133 // given hash algorithm 'algo'.
134 fn pkcs1_sig_encode(
135 sig: []u8,
136 msghash: []u8,
137 algo: pkcs1_hashalgo
138 ) (void | error) = {
139 let (hid, hsz) = pkcs1_hashinfo(algo);
140 if (len(msghash) != hsz) {
141 return errors::invalid;
142 };
143
144 let tlen = len(hid) + hsz;
145 if (len(sig) < tlen + 11) {
146 return badsig;
147 };
148
149 const hsep = len(sig) - tlen - 1;
150
151 sig[..2] = [0x00, 0x01];
152 for (let i = 2z; i < hsep; i += 1) {
153 sig[i] = 0xff;
154 };
155 sig[hsep] = 0x00;
156 sig[hsep + 1..len(sig) - hsz] = hid[..];
157 sig[len(sig) - hsz..] = msghash[..];
158 };