1 # Every instance through its interface, on the specifications' own vectors: 2 # each block cipher's vector both ways (encryption, then decryption back), 3 # the modes over the interface (SP 800-38A's ECB, CBC and CTR vectors, and 4 # 3DES CBC from SP 800-67), RC4 (RFC 6229) whole and in pieces, CMAC 5 # (RFC 4493), CCM (RFC 3610) with tampered input refused, the CRC check 6 # values, HMAC and HKDF over CRC-32 (values from Python's hmac, which 7 # ref/gen.py also checks), long messages both ways, the refusals; then 8 # SHA-256 and SHA-512 (FIPS 180-4's examples, whole and in pieces), 9 # HMAC-SHA-256 and HMAC-SHA-512 (RFC 4231 test cases 1 to 7) and 10 # HKDF-SHA-256 (RFC 5869 A.1 to A.3); SHA3-256 (FIPS 202: NIST's examples 11 # for "abc", the empty message and 200 bytes of a3, whole and in pieces) 12 # and HMAC-SHA3-256 (the value of Python's hmac over hashlib); then the 13 # newer instances (ARIA, CAST-256, Blowfish, CAST-128, TEA, XTEA, FCrypt) 14 # on their specifications' vectors both ways (TEA and XTEA on 15 # legacy-ciphers' model values: their papers give none), PCBC (the FCrypt 16 # specification's PCBC vector), LRW-AES (the IEEE P1619 draft's Annex B), 17 # CBC-CS3 (RFC 3962's AES vectors, both ways, and a refused short message), 18 # AES-XCBC-MAC (RFC 3566's seven) and VMAC-AES (draft-krovetz-vmac-01's, 19 # 64- and 128-bit tags). 20 import Base 21 import bend-osdev-bytes@0.1.0.0/bytes.bend as B 22 import bend-osdev-word64@0.1.0.0/word64.bend as W 23 import bend-osdev-cipher-modes@0.1.0.0/cipher_modes.bend as M 24 import bend-osdev-cipher-modes@0.1.0.0/aes.bend as X 25 import bend-osdev-legacy-ciphers@0.1.0.0/legacy_ciphers.bend as L 26 import bend-osdev-legacy-ciphers@0.1.0.0/des.bend as D 27 import bend-osdev-legacy-ciphers@0.1.0.0/tdes.bend as T 28 import bend-osdev-legacy-ciphers@0.1.0.0/sm4.bend as S 29 import bend-osdev-legacy-ciphers@0.1.0.0/camellia.bend as Ca 30 import bend-osdev-legacy-ciphers@0.1.0.0/serpent.bend as Sp 31 import bend-osdev-legacy-ciphers@0.1.0.0/twofish.bend as Tf 32 import bend-osdev-legacy-ciphers@0.1.0.0/rc4.bend as R 33 import bend-osdev-crc@0.1.0.0/crc.bend as C 34 import ./crypto.bend as Cr 35 import ./stream.bend as St 36 import ./block.bend as Bk 37 import ./modes.bend as Md 38 import ./hash.bend as H 39 import ./mac.bend as Mc 40 import ./hmac.bend as Hm 41 import ./hkdf.bend as Hk 42 import ./aead.bend as Ae 43 import ./inst_cm.bend as CM 44 import ./inst_lc.bend as LC 45 import ./inst_aes.bend as A 46 import ./inst_rc4.bend as RC 47 import ./inst_ccm.bend as CC 48 import ./inst_cmac.bend as CMI 49 import ./inst_crc.bend as CR 50 import ./inst_sha2.bend as SH 51 import ./inst_sha3.bend as S3 52 import ./pcbc.bend as Pc 53 import ./lrw.bend as Lw 54 import ./cts.bend as Ct 55 import ./xcbc.bend as Xc 56 import ./vmac.bend as Vm 57 import bend-osdev-legacy-ciphers@0.1.0.0/aria.bend as Ar 58 import bend-osdev-legacy-ciphers@0.1.0.0/cast6.bend as C6 59 import bend-osdev-legacy-ciphers@0.1.0.0/blowfish.bend as Bf 60 import bend-osdev-legacy-ciphers@0.1.0.0/cast5.bend as C5 61 import bend-osdev-legacy-ciphers@0.1.0.0/tea.bend as Te 62 import bend-osdev-legacy-ciphers@0.1.0.0/xtea.bend as Xt 63 import bend-osdev-legacy-ciphers@0.1.0.0/fcrypt.bend as Fc 64 import ./inst_michael.bend as MIC 65 import ./pbkdf2.bend as Pb 66 import ./inst_pbkdf2.bend as PbI 67 import ./kbkdf.bend as Kb 68 import ./inst_kbkdf.bend as KbI 69 import bend-osdev-hashes@0.1.0.0/hashes.bend as Hs 70 import bend-osdev-hashes@0.1.0.0/md4.bend as HM4 71 import bend-osdev-hashes@0.1.0.0/md5.bend as HM5 72 import bend-osdev-hashes@0.1.0.0/sha1.bend as HS1 73 import bend-osdev-hashes@0.1.0.0/ripemd160.bend as HRM 74 import bend-osdev-hashes@0.1.0.0/sm3.bend as HSM 75 import bend-osdev-hashes@0.1.0.0/streebog.bend as HST 76 import bend-osdev-hashes@0.1.0.0/michael.bend as HMI 77 78 def cat(a: String, b: String) -> String: 79 a ++ b 80 81 def err(e: Cr.CrError) -> String: 82 match e: 83 case Cr.CrBadKeyLength{n}: 84 cat("bad key length ", Nat.show(n)) 85 case Cr.CrBadIvLength{n}: 86 cat("bad iv length ", Nat.show(n)) 87 case Cr.CrNotBlockMultiple{n}: 88 cat("not whole blocks ", Nat.show(n)) 89 case Cr.CrBadBlockSize{n}: 90 cat("bad block size ", Nat.show(n)) 91 case Cr.CrTagMismatch{}: 92 "tag mismatch" 93 case Cr.CrBadOutputLength{n}: 94 cat("bad output length ", Nat.show(n)) 95 case Cr.CrTooShort{n}: 96 cat("too short ", Nat.show(n)) 97 case _: 98 "other error" 99 100 def show(r: Result<&2, &2, Cr.CrError, B.Octets>) -> String: 101 match r: 102 case Done{o}: 103 B.Octets.hex(o) 104 case Fail{e}: 105 err(e) 106 107 def cr.check.base(digit: Bool) -> U32: 108 match digit: 109 case True{}: 110 48 111 case False{}: 112 87 113 114 def cr.check.nib(+c: U32) -> U32: 115 U32.sub(c, cr.check.base(U32.is_lt(c, 58))) 116 117 def cr.check.hex(cs: List<&2, U32>, acc: List<&2, U32>) -> List<&2, U32>: 118 match cs: 119 case Con{a, Con{b, t}}: 120 cr.check.hex(t, Con{U32.add(U32.mul(cr.check.nib(a), 16), cr.check.nib(b)), acc}) 121 case _: 122 B.rev(acc) 123 124 def yes_no(b: Bool) -> String: 125 match b: 126 case True{}: 127 "accepted" 128 case False{}: 129 "refused" 130 131 def cr.check.two.go(~S: Data, ~update: S -> B.Octets -> St.CrXorOut, o: St.CrXorOut, b: B.Octets) -> B.Octets: 132 match o: 133 case St.CrXorOut{s, d}: 134 B.Octets.append(d, St.CrXor.out_data(~S, update(s, b))) 135 136 def cr.check.two(~S: Data, ~update: S -> B.Octets -> St.CrXorOut, s: S, a: B.Octets, b: B.Octets) -> B.Octets: 137 cr.check.two.go(~S, ~update, update(s, a), b) 138 139 def cr.check.rc4two(+o: R.LcRc4Out) -> B.Octets: 140 B.Octets.append(R.LcRc4.out_data(o), R.LcRc4.out_data(R.LcRc4.update(R.LcRc4.out_state(o), B.Octets.zeros(11n)))) 141 142 def cr.check.verify(r: Result<&2, &2, Cr.CrError, Bool>) -> String: 143 match r: 144 case Done{b}: 145 cat(" ", yes_no(b)) 146 case Fail{e}: 147 " failed" 148 149 def hx(s: String) -> B.Octets: 150 B.Octets.of_list(cr.check.hex(B.Octets.to_list(B.Octets.of_string(s)), Nil{})) 151 152 # encryption, then decryption back: " " 153 def both(e: Result<&2, &2, Cr.CrError, B.Octets>, d: Result<&2, &2, Cr.CrError, B.Octets>) -> String: 154 cat(show(e), cat(" ", show(d))) 155 156 def ok_if(same: Bool, tail: B.Octets) -> String: 157 match same: 158 case True{}: 159 cat(B.Octets.hex(tail), " ok") 160 case False{}: 161 "MISMATCH" 162 163 # the last 16 bytes of c, and whether d gave the message back 164 def round(+m: B.Octets, c: Result<&2, &2, Cr.CrError, B.Octets>, d: Result<&2, &2, Cr.CrError, B.Octets>) -> String: 165 match c d: 166 case Done{+x} Done{y}: 167 ok_if(B.Octets.is_eq(y, m), B.Octets.drop(Nat.sub(B.Octets.len(x), 16n), x)) 168 case _ _: 169 "failed" 170 171 # Block ciphers, one block through the interface (key schedule, then bytes) 172 173 def aes(+k: B.Octets, +p: B.Octets) -> String: 174 both(Bk.CrBlockCipher.encrypt_with(~X.CmAesKey, ~M.CmBlock, ~A.CrAes.key, ~X.CmAes.encrypt, ~CM.CrBlk128.of_octets, ~CM.CrBlk128.to_octets, k, p), Result.bind(&2, &2, Cr.CrError, B.Octets, B.Octets, Bk.CrBlockCipher.encrypt_with(~X.CmAesKey, ~M.CmBlock, ~A.CrAes.key, ~X.CmAes.encrypt, ~CM.CrBlk128.of_octets, ~CM.CrBlk128.to_octets, k, p), c => Bk.CrBlockCipher.encrypt_with(~X.CmAesKey, ~M.CmBlock, ~A.CrAes.key, ~X.CmAes.decrypt, ~CM.CrBlk128.of_octets, ~CM.CrBlk128.to_octets, k, c))) 175 176 def lc128(~K: Data, ~key: B.Octets -> Result<&2, &2, Cr.CrError, K>, ~enc: K -> M.CmBlock -> M.CmBlock, ~dec: K -> M.CmBlock -> M.CmBlock, +k: B.Octets, +p: B.Octets) -> String: 177 +c = Bk.CrBlockCipher.encrypt_with(~K, ~M.CmBlock, ~key, ~enc, ~CM.CrBlk128.of_octets, ~CM.CrBlk128.to_octets, k, p) 178 both(c, Result.bind(&2, &2, Cr.CrError, B.Octets, B.Octets, c, x => Bk.CrBlockCipher.encrypt_with(~K, ~M.CmBlock, ~key, ~dec, ~CM.CrBlk128.of_octets, ~CM.CrBlk128.to_octets, k, x))) 179 180 def lc64(~K: Data, ~key: B.Octets -> Result<&2, &2, Cr.CrError, K>, ~enc: K -> L.LcBlock64 -> L.LcBlock64, ~dec: K -> L.LcBlock64 -> L.LcBlock64, +k: B.Octets, +p: B.Octets) -> String: 181 +c = Bk.CrBlockCipher.encrypt_with(~K, ~L.LcBlock64, ~key, ~enc, ~L.LcBlock64.of_octets, ~L.LcBlock64.to_octets, k, p) 182 both(c, Result.bind(&2, &2, Cr.CrError, B.Octets, B.Octets, c, x => Bk.CrBlockCipher.encrypt_with(~K, ~L.LcBlock64, ~key, ~dec, ~L.LcBlock64.of_octets, ~L.LcBlock64.to_octets, k, x))) 183 184 # Modes over the interface 185 186 def aes_ecb(+k: B.Octets, +m: B.Octets) -> String: 187 +r = A.CrAes.key(k) 188 +c = Result.bind(&2, &2, Cr.CrError, X.CmAesKey, B.Octets, r, kk => Md.CrEcb.encrypt(~X.CmAesKey, ~M.CmBlock, ~16n, ~X.CmAes.encrypt, ~CM.CrBlk128.of_octets, ~CM.CrBlk128.to_octets, kk, m)) 189 both(c, Result.bind(&2, &2, Cr.CrError, X.CmAesKey, B.Octets, r, kk => Result.bind(&2, &2, Cr.CrError, B.Octets, B.Octets, c, x => Md.CrEcb.decrypt(~X.CmAesKey, ~M.CmBlock, ~16n, ~X.CmAes.decrypt, ~CM.CrBlk128.of_octets, ~CM.CrBlk128.to_octets, kk, x)))) 190 191 def aes_cbc_c(+k: B.Octets, +iv: B.Octets, +m: B.Octets) -> Result<&2, &2, Cr.CrError, B.Octets>: 192 Result.bind(&2, &2, Cr.CrError, X.CmAesKey, B.Octets, A.CrAes.key(k), kk => Md.CrCbc.encrypt(~X.CmAesKey, ~M.CmBlock, ~16n, ~X.CmAes.encrypt, ~CM.CrBlk128.xor, ~CM.CrBlk128.of_octets, ~CM.CrBlk128.to_octets, kk, iv, m)) 193 194 def aes_cbc_d(+k: B.Octets, +iv: B.Octets, c: Result<&2, &2, Cr.CrError, B.Octets>) -> Result<&2, &2, Cr.CrError, B.Octets>: 195 Result.bind(&2, &2, Cr.CrError, X.CmAesKey, B.Octets, A.CrAes.key(k), kk => Result.bind(&2, &2, Cr.CrError, B.Octets, B.Octets, c, x => Md.CrCbc.decrypt(~X.CmAesKey, ~M.CmBlock, ~16n, ~X.CmAes.decrypt, ~CM.CrBlk128.xor, ~CM.CrBlk128.of_octets, ~CM.CrBlk128.to_octets, kk, iv, x))) 196 197 def aes_cbc(+k: B.Octets, +iv: B.Octets, +m: B.Octets) -> String: 198 +c = aes_cbc_c(k, iv, m) 199 both(c, aes_cbc_d(k, iv, c)) 200 201 def tdes_cbc(+k: B.Octets, +iv: B.Octets, +m: B.Octets) -> String: 202 +r = LC.CrLc.key(~T.LcTdesKey, ~T.LcTdes.key, k) 203 +c = Result.bind(&2, &2, Cr.CrError, T.LcTdesKey, B.Octets, r, kk => Md.CrCbc.encrypt(~T.LcTdesKey, ~L.LcBlock64, ~8n, ~T.LcTdes.encrypt, ~LC.CrBlk64.xor, ~L.LcBlock64.of_octets, ~L.LcBlock64.to_octets, kk, iv, m)) 204 both(c, Result.bind(&2, &2, Cr.CrError, T.LcTdesKey, B.Octets, r, kk => Result.bind(&2, &2, Cr.CrError, B.Octets, B.Octets, c, x => Md.CrCbc.decrypt(~T.LcTdesKey, ~L.LcBlock64, ~8n, ~T.LcTdes.decrypt, ~LC.CrBlk64.xor, ~L.LcBlock64.of_octets, ~L.LcBlock64.to_octets, kk, iv, x)))) 205 206 # CTR-AES as a stream cipher through the stream interface 207 def aes_ctr(+k: B.Octets, +iv: B.Octets, m: B.Octets) -> Result<&2, &2, Cr.CrError, B.Octets>: 208 St.CrStream.crypt(~Md.CrCtrState<X.CmAesKey>, ~St.CrXorOut<Md.CrCtrState<X.CmAesKey>>, ~Md.CrCtr.start(~X.CmAesKey, ~16n, ~A.CrAes.key_enc), ~Md.CrCtr.update(~X.CmAesKey, ~M.CmBlock, ~X.CmAes.encrypt, ~CM.CrBlk128.of_octets, ~CM.CrBlk128.to_octets), ~St.CrXor.out_data(~Md.CrCtrState<X.CmAesKey>), k, iv, m) 209 210 # CTR-DES, in pieces: two updates from one start 211 def des_ctr_pieces(+k: B.Octets, +iv: B.Octets, +a: B.Octets, +b: B.Octets) -> Result<&2, &2, Cr.CrError, B.Octets>: 212 Result.map(&2, &2, Cr.CrError, Md.CrCtrState<D.LcDesKey>, B.Octets, +s => cr.check.two(~Md.CrCtrState<D.LcDesKey>, ~Md.CrCtr.update(~D.LcDesKey, ~L.LcBlock64, ~D.LcDes.encrypt, ~L.LcBlock64.of_octets, ~L.LcBlock64.to_octets), s, a, b), Md.CrCtr.start(~D.LcDesKey, ~8n, ~LC.CrLc.key(~D.LcDesKey, ~D.LcDes.key), k, iv)) 213 214 # RC4 through the stream interface: the keystream, and the same in pieces 215 def rc4(+k: B.Octets, n: Nat) -> Result<&2, &2, Cr.CrError, B.Octets>: 216 St.CrStream.crypt(~R.LcRc4State, ~R.LcRc4Out, ~RC.CrRc4.start, ~R.LcRc4.update, ~R.LcRc4.out_data, k, B.Octets.empty(), B.Octets.zeros(n)) 217 218 def rc4_pieces(+k: B.Octets) -> Result<&2, &2, Cr.CrError, B.Octets>: 219 Result.map(&2, &2, Cr.CrError, R.LcRc4State, B.Octets, +s => cr.check.rc4two(R.LcRc4.update(s, B.Octets.zeros(5n))), RC.CrRc4.start(k, B.Octets.empty())) 220 221 def rc4_drop(+k: B.Octets) -> Result<&2, &2, Cr.CrError, B.Octets>: 222 St.CrStream.crypt(~R.LcRc4State, ~R.LcRc4Out, ~RC.CrRc4.start_drop(~1536n), ~R.LcRc4.update, ~R.LcRc4.out_data, k, B.Octets.empty(), B.Octets.zeros(16n)) 223 224 # CMAC-AES through the MAC interface: the tag, and whether verify accepts it 225 # and refuses it with its last byte changed 226 def flip_last(+t: B.Octets) -> B.Octets: 227 B.Octets.append(B.Octets.take(Nat.sub(B.Octets.len(t), 1n), t), B.Octets.of_list([U32.xor(Maybe.default(&2, U32, B.Octets.at(t, Nat.sub(B.Octets.len(t), 1n)), 0), 1)])) 228 229 def cmac(+k: B.Octets, +m: B.Octets) -> String: 230 +t = Mc.CrMac.compute_with(~X.CmAesKey, ~A.CrAes.key_enc, ~CMI.CrCmac.mac(~X.CmAesKey, ~X.CmAes.encrypt), k, m) 231 cat(show(t), cr.check.verify(Result.map(&2, &2, Cr.CrError, B.Octets, Bool, +tag => Result.default(&2, &2, Cr.CrError, Bool, Result.map(&2, &2, Cr.CrError, X.CmAesKey, Bool, +kk => Bool.and(CMI.CrCmac.verify(~X.CmAesKey, ~X.CmAes.encrypt, kk, m, tag), Bool.not(CMI.CrCmac.verify(~X.CmAesKey, ~X.CmAes.encrypt, kk, m, flip_last(tag)))), A.CrAes.key_enc(k)), False{}), t))) 232 233 # CCM-AES through the AEAD interface, an m-byte tag: the sealed message, the 234 # plaintext opened again, and the result of opening it with the tag's last 235 # byte changed 236 def ccm(~tlen: Nat, +k: B.Octets, +n: B.Octets, +a: B.Octets, +p: B.Octets) -> String: 237 +c = Ae.CrAead.seal_with(~X.CmAesKey, ~A.CrAes.key_enc, ~CC.CrCcm.seal(~X.CmAesKey, ~X.CmAes.encrypt, ~tlen), k, n, a, p) 238 +o = Result.bind(&2, &2, Cr.CrError, B.Octets, B.Octets, c, x => Ae.CrAead.open_with(~X.CmAesKey, ~A.CrAes.key_enc, ~CC.CrCcm.open(~X.CmAesKey, ~X.CmAes.encrypt, ~tlen), k, n, a, x)) 239 +bad = Result.bind(&2, &2, Cr.CrError, B.Octets, B.Octets, c, x => Ae.CrAead.open_with(~X.CmAesKey, ~A.CrAes.key_enc, ~CC.CrCcm.open(~X.CmAesKey, ~X.CmAes.encrypt, ~tlen), k, n, a, flip_last(x))) 240 cat(show(c), cat(" ", cat(show(o), cat(" ", show(bad))))) 241 242 # CRC-32 through the hash interface: one-shot, and in three pieces 243 def crc32_pieces(+m1: B.Octets, +m2: B.Octets, +m3: B.Octets) -> String: 244 cat(B.Octets.hex(CR.CrCrc32.digest(~C.crc32c.spec(), B.Octets.append(m1, B.Octets.append(m2, m3)))), cat(" ", B.Octets.hex(H.CrHash.of_pieces(~U32, ~CR.CrCrc32.init(~C.crc32c.spec()), ~CR.CrCrc32.update(~C.crc32c.spec()), ~CR.CrCrc32.final(~C.crc32c.spec()), [m1, m2, m3])))) 245 246 # HMAC over CRC-32: one-shot, in two pieces, and verify 247 def hmac_crc32(+k: B.Octets, +a: B.Octets, +b: B.Octets) -> String: 248 +kk = Hm.CrHmac.key(~64n, ~CR.CrCrc32.digest(~C.crc32.spec()), k) 249 +t = Hm.CrHmac.mac(~CR.CrCrc32.digest(~C.crc32.spec()), kk, B.Octets.append(a, b)) 250 +s = Hm.CrHmac.start(~U32, ~CR.CrCrc32.init(~C.crc32.spec()), ~CR.CrCrc32.update(~C.crc32.spec()), kk) 251 +t2 = Hm.CrHmac.finish(~U32, ~CR.CrCrc32.init(~C.crc32.spec()), ~CR.CrCrc32.update(~C.crc32.spec()), ~CR.CrCrc32.final(~C.crc32.spec()), Hm.CrHmac.update(~U32, ~CR.CrCrc32.update(~C.crc32.spec()), Hm.CrHmac.update(~U32, ~CR.CrCrc32.update(~C.crc32.spec()), s, a), b)) 252 cat(B.Octets.hex(t), cat(" ", cat(B.Octets.hex(t2), cat(" ", yes_no(Hm.CrHmac.verify(~CR.CrCrc32.digest(~C.crc32.spec()), kk, B.Octets.append(a, b), t)))))) 253 254 # HMAC over CRC-64/XZ, with a key longer than the block size (hashed first) 255 def hmac_crc64(+k: B.Octets, +m: B.Octets) -> String: 256 B.Octets.hex(Hm.CrHmac.mac(~CR.CrCrc64.digest(~C.crc64_xz.spec()), Hm.CrHmac.key(~64n, ~CR.CrCrc64.digest(~C.crc64_xz.spec()), k), m)) 257 258 def hkdf_crc32(+ikm: B.Octets, +salt: B.Octets, +info: B.Octets, n: Nat) -> String: 259 show(Hk.CrHkdf.derive(~64n, ~4n, ~CR.CrCrc32.digest(~C.crc32.spec()), ikm, salt, info, n)) 260 261 def cr.check.tail8(r: Result<&2, &2, Cr.CrError, B.Octets>) -> String: 262 match r: 263 case Done{+o}: 264 cat(Nat.show(B.Octets.len(o)), cat(" ", B.Octets.hex(B.Octets.drop(Nat.sub(B.Octets.len(o), 8n), o)))) 265 case Fail{e}: 266 err(e) 267 268 # the longest HKDF output (255 digests): its length and last 8 bytes 269 def hkdf_crc32_max(+ikm: B.Octets) -> String: 270 cr.check.tail8(Hk.CrHkdf.derive(~64n, ~4n, ~CR.CrCrc32.digest(~C.crc32.spec()), ikm, B.Octets.empty(), B.Octets.empty(), 1020n)) 271 272 # a long message: n pseudo-random bytes 273 def big.go(n: Nat, +x: U32, acc: List<&2, U32>) -> List<&2, U32>: 274 match n: 275 case 0n: 276 acc 277 case 1n+p: 278 big.go(p, U32.add(U32.mul(x, 1103515245), 12345), Con{B.byte(U32.shrn(x, 16n)), acc}) 279 280 def big(n: Nat) -> B.Octets: 281 B.Octets.of_list(big.go(n, 7, Nil{})) 282 283 def sm4_cbc_big(+k: B.Octets, +iv: B.Octets, +m: B.Octets) -> String: 284 +r = LC.CrLc.key(~S.LcSm4Key, ~S.LcSm4.key, k) 285 +c = Result.bind(&2, &2, Cr.CrError, S.LcSm4Key, B.Octets, r, kk => Md.CrCbc.encrypt(~S.LcSm4Key, ~M.CmBlock, ~16n, ~S.LcSm4.encrypt, ~CM.CrBlk128.xor, ~CM.CrBlk128.of_octets, ~CM.CrBlk128.to_octets, kk, iv, m)) 286 round(m, c, Result.bind(&2, &2, Cr.CrError, S.LcSm4Key, B.Octets, r, kk => Result.bind(&2, &2, Cr.CrError, B.Octets, B.Octets, c, x => Md.CrCbc.decrypt(~S.LcSm4Key, ~M.CmBlock, ~16n, ~S.LcSm4.decrypt, ~CM.CrBlk128.xor, ~CM.CrBlk128.of_octets, ~CM.CrBlk128.to_octets, kk, iv, x)))) 287 288 def aes_ctr_big(+k: B.Octets, +iv: B.Octets, +m: B.Octets) -> String: 289 +c = aes_ctr(k, iv, m) 290 round(m, c, Result.bind(&2, &2, Cr.CrError, B.Octets, B.Octets, c, x => aes_ctr(k, iv, x))) 291 292 # SHA-256 and SHA-512 through the hash interface: one-shot, and in three 293 # pieces through the streaming interface 294 def sha(~digest: B.Octets -> B.Octets, +m: B.Octets) -> String: 295 B.Octets.hex(digest(m)) 296 297 def sha_pieces3(~init: SH.CrSha2State, +a: B.Octets, +b: B.Octets, +c: B.Octets) -> String: 298 B.Octets.hex(H.CrHash.of_pieces(~SH.CrSha2State, ~init, ~SH.CrSha2.update, ~SH.CrSha2.final, [a, b, c])) 299 300 # HMAC over SHA-256 or SHA-512 (block size bsize) 301 def hmac_sha(~bsize: Nat, ~digest: B.Octets -> B.Octets, +k: B.Octets, +m: B.Octets) -> B.Octets: 302 Hm.CrHmac.mac(~digest, Hm.CrHmac.key(~bsize, ~digest, k), m) 303 304 # HMAC-SHA-256 in two pieces, and verify of the tag 305 def hmac_sha256_pieces(+k: B.Octets, +a: B.Octets, +b: B.Octets) -> String: 306 +kk = Hm.CrHmac.key(~64n, ~SH.CrSha2.sha256, k) 307 +t = Hm.CrHmac.finish(~SH.CrSha2State, ~SH.CrSha2.init256(), ~SH.CrSha2.update, ~SH.CrSha2.final, Hm.CrHmac.update(~SH.CrSha2State, ~SH.CrSha2.update, Hm.CrHmac.update(~SH.CrSha2State, ~SH.CrSha2.update, Hm.CrHmac.start(~SH.CrSha2State, ~SH.CrSha2.init256(), ~SH.CrSha2.update, kk), a), b)) 308 cat(B.Octets.hex(t), cat(" ", yes_no(Hm.CrHmac.verify(~SH.CrSha2.sha256, kk, B.Octets.append(a, b), t)))) 309 310 def hkdf_sha256(+ikm: B.Octets, +salt: B.Octets, +info: B.Octets, n: Nat) -> String: 311 show(Hk.CrHkdf.derive(~64n, ~32n, ~SH.CrSha2.sha256, ikm, salt, info, n)) 312 313 # The newer modes and MACs 314 315 def pcbc_fc(+k: B.Octets, +iv: B.Octets, +m: B.Octets) -> String: 316 +r = LC.CrLc.key(~Fc.LcFcryptKey, ~Fc.LcFcrypt.key, k) 317 +c = Result.bind(&2, &2, Cr.CrError, Fc.LcFcryptKey, B.Octets, r, kk => Pc.CrPcbc.encrypt(~Fc.LcFcryptKey, ~L.LcBlock64, ~8n, ~Fc.LcFcrypt.encrypt, ~LC.CrBlk64.xor, ~L.LcBlock64.of_octets, ~L.LcBlock64.to_octets, kk, iv, m)) 318 both(c, Result.bind(&2, &2, Cr.CrError, Fc.LcFcryptKey, B.Octets, r, kk => Result.bind(&2, &2, Cr.CrError, B.Octets, B.Octets, c, x => Pc.CrPcbc.decrypt(~Fc.LcFcryptKey, ~L.LcBlock64, ~8n, ~Fc.LcFcrypt.decrypt, ~LC.CrBlk64.xor, ~L.LcBlock64.of_octets, ~L.LcBlock64.to_octets, kk, iv, x)))) 319 320 def lrw_aes(+k: B.Octets, +iv: B.Octets, +m: B.Octets) -> String: 321 +r = Lw.CrLrw.key(~X.CmAesKey, ~A.CrAes.key, k) 322 +c = Result.bind(&2, &2, Cr.CrError, Lw.CrLrwKey<X.CmAesKey>, B.Octets, r, kk => Lw.CrLrw.encrypt(~X.CmAesKey, ~M.CmBlock, ~16n, ~X.CmAes.encrypt, ~CM.CrBlk128.xor, ~CM.CrBlk128.of_octets, ~CM.CrBlk128.to_octets, kk, iv, m)) 323 both(c, Result.bind(&2, &2, Cr.CrError, Lw.CrLrwKey<X.CmAesKey>, B.Octets, r, kk => Result.bind(&2, &2, Cr.CrError, B.Octets, B.Octets, c, x => Lw.CrLrw.decrypt(~X.CmAesKey, ~M.CmBlock, ~16n, ~X.CmAes.decrypt, ~CM.CrBlk128.xor, ~CM.CrBlk128.of_octets, ~CM.CrBlk128.to_octets, kk, iv, x)))) 324 325 def cts_aes(+k: B.Octets, +iv: B.Octets, +m: B.Octets) -> String: 326 +r = A.CrAes.key(k) 327 +c = Result.bind(&2, &2, Cr.CrError, X.CmAesKey, B.Octets, r, kk => Ct.CrCts.encrypt(~X.CmAesKey, ~M.CmBlock, ~16n, ~X.CmAes.encrypt, ~CM.CrBlk128.of_octets, ~CM.CrBlk128.to_octets, kk, iv, m)) 328 both(c, Result.bind(&2, &2, Cr.CrError, X.CmAesKey, B.Octets, r, kk => Result.bind(&2, &2, Cr.CrError, B.Octets, B.Octets, c, x => Ct.CrCts.decrypt(~X.CmAesKey, ~M.CmBlock, ~16n, ~X.CmAes.decrypt, ~CM.CrBlk128.of_octets, ~CM.CrBlk128.to_octets, kk, iv, x)))) 329 330 def xcbc_aes(+k: B.Octets, +m: B.Octets) -> String: 331 show(Result.map(&2, &2, Cr.CrError, Xc.CrXcbcKey<X.CmAesKey>, B.Octets, kk => Xc.CrXcbc.mac(~X.CmAesKey, ~M.CmBlock, ~16n, ~X.CmAes.encrypt, ~CM.CrBlk128.of_octets, ~CM.CrBlk128.to_octets, kk, m), Xc.CrXcbc.key(~X.CmAesKey, ~M.CmBlock, ~16n, ~A.CrAes.key, ~X.CmAes.encrypt, ~CM.CrBlk128.of_octets, ~CM.CrBlk128.to_octets, k))) 332 333 def vmac_aes(~words: Nat, +k: B.Octets, +n: B.Octets, +m: B.Octets) -> String: 334 show(Result.bind(&2, &2, Cr.CrError, Vm.CrVmacKey<X.CmAesKey>, B.Octets, Vm.CrVmac.key(~X.CmAesKey, ~M.CmBlock, ~16n, ~A.CrAes.key, ~X.CmAes.encrypt, ~CM.CrBlk128.of_octets, ~CM.CrBlk128.to_octets, ~words, k), kk => Vm.CrVmac.tag(~X.CmAesKey, ~M.CmBlock, ~16n, ~X.CmAes.encrypt, ~CM.CrBlk128.of_octets, ~CM.CrBlk128.to_octets, kk, n, m))) 335 336 def rep(n: Nat, +s: String, acc: String) -> String: 337 match n: 338 case 0n: 339 acc 340 case 1n+p: 341 rep(p, s, cat(acc, s)) 342 def cr.check.first.of(m: Maybe<&2, U32>) -> U32: 343 match m: 344 case Some{b}: 345 b 346 case None{}: 347 0 348 349 def cr.check.first(+o: B.Octets) -> U32: 350 cr.check.first.of(B.Octets.at(o, 0n)) 351 352 # The hashes package's hashes through the hash interface: the one-shot 353 # digest, and the digest of three pieces through init / update / final 354 def hs_hash(~H: Data, ~init: H, ~update: H -> B.Octets -> H, ~final: H -> B.Octets, ~digest: B.Octets -> B.Octets, +a: B.Octets, +b: B.Octets, +c: B.Octets) -> String: 355 cat(B.Octets.hex(digest(B.Octets.append(a, B.Octets.append(b, c)))), cat(" ", B.Octets.hex(H.CrHash.of_pieces(~H, ~init, ~update, ~final, [a, b, c])))) 356 357 # HMAC over a hash of the hashes package, in one call and in two pieces, 358 # and verify of the tag 359 def hs_hmac(~H: Data, ~bsize: Nat, ~init: H, ~update: H -> B.Octets -> H, ~final: H -> B.Octets, ~digest: B.Octets -> B.Octets, +k: B.Octets, +a: B.Octets, +b: B.Octets) -> String: 360 +kk = Hm.CrHmac.key(~bsize, ~digest, k) 361 +t = Hm.CrHmac.mac(~digest, kk, B.Octets.append(a, b)) 362 +t2 = Hm.CrHmac.finish(~H, ~init, ~update, ~final, Hm.CrHmac.update(~H, ~update, Hm.CrHmac.update(~H, ~update, Hm.CrHmac.start(~H, ~init, ~update, kk), a), b)) 363 cat(B.Octets.hex(t), cat(" ", cat(B.Octets.hex(t2), cat(" ", yes_no(Hm.CrHmac.verify(~digest, kk, B.Octets.append(a, b), t)))))) 364 365 # Michael through the MAC interface: the tag, verify of it, and of it with 366 # its first byte changed 367 def michael_mac.of(r: Result<&2, &2, Cr.CrError, Hs.HsW2>, +m: B.Octets) -> String: 368 match r: 369 case Fail{e}: 370 err(e) 371 case Done{+k}: 372 +t = HMI.HsMichael.mic(k, m) 373 cat(B.Octets.hex(t), cat(" ", cat(yes_no(MIC.CrMichael.verify(k, m, t)), cat(" ", yes_no(MIC.CrMichael.verify(k, m, B.Octets.append(B.Octets.of_list([U32.xor(cr.check.first(t), 1)]), B.Octets.drop(1n, t)))))))) 374 375 def michael_mac(k: B.Octets, +m: B.Octets) -> String: 376 michael_mac.of(MIC.CrMichael.key(k), m) 377 378 def pbkdf2_sha1(+p: B.Octets, +s: B.Octets, c: U32, n: Nat) -> String: 379 show(PbI.CrPbkdf2.hmac_sha1(p, s, c, n)) 380 381 def pbkdf2_sha256(+p: B.Octets, +s: B.Octets, c: U32, n: Nat) -> String: 382 show(PbI.CrPbkdf2.hmac_sha256(p, s, c, n)) 383 384 # PBKDF2 over HMAC-MD5 through the KDF interface (info ignored) 385 def pbkdf2_md5_kdf(+p: B.Octets, +s: B.Octets, n: Nat) -> String: 386 show(Pb.CrPbkdf2.derive(~Hm.CrHmacKey, ~Hm.CrHmac.key_of(~64n, ~HM5.HsMd5.digest), ~Hm.CrHmac.mac(~HM5.HsMd5.digest), ~16n, ~1000, p, s, B.Octets.of_string("ignored"), n)) 387 388 # SP 800-108 over HMAC-SHA-256: counter mode (cryptography's KBKDFHMAC 389 # gives the value), feedback mode (ref/gen.py's SP 800-108), and an output 390 # too long for a one-byte counter refused 391 def kbkdf_counter(n: Nat) -> String: 392 show(KbI.CrKbkdf.hmac_sha256_counter(B.Octets.of_string("secret key bytes"), B.Octets.of_string("label"), B.Octets.of_string("context"), n)) 393 394 def kbkdf_feedback(n: Nat) -> String: 395 show(KbI.CrKbkdf.hmac_sha256_feedback(B.Octets.of_string("secret key bytes"), B.Octets.of_string("an iv"), B.Octets.of_string("label"), B.Octets.of_string("context"), n)) 396 397 def kbkdf_short_counter(n: Nat) -> String: 398 show(Kb.CrKbkdf.counter_kdf(~Hm.CrHmacKey, ~Hm.CrHmac.key_of(~64n, ~SH.CrSha2.sha256), ~Hm.CrHmac.mac(~SH.CrSha2.sha256), ~32n, ~1n, ~4n, B.Octets.of_string("k"), B.Octets.empty(), B.Octets.empty(), n)) 399 400 def main() -> IO(Unit): 401 +k16 = hx("0123456789abcdeffedcba9876543210") 402 +z16 = B.Octets.zeros(16n) 403 +nk = hx("2b7e151628aed2a6abf7158809cf4f3c") 404 +f4 = hx("6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c81c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417be66c3710") 405 +ck = hx("c0c1c2c3c4c5c6c7c8c9cacbcccdcecf") 406 do IO<Unit>: 407 IO.print(aes(hx("000102030405060708090a0b0c0d0e0f"), hx("00112233445566778899aabbccddeeff"))) 408 IO.print(aes(hx("000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f"), hx("00112233445566778899aabbccddeeff"))) 409 IO.print(lc64(~D.LcDesKey, ~LC.CrLc.key(~D.LcDesKey, ~D.LcDes.key), ~D.LcDes.encrypt, ~D.LcDes.decrypt, hx("0101010101010101"), hx("8000000000000000"))) 410 IO.print(lc64(~T.LcTdesKey, ~LC.CrLc.key(~T.LcTdesKey, ~T.LcTdes.key), ~T.LcTdes.encrypt, ~T.LcTdes.decrypt, hx("0123456789abcdef23456789abcdef01456789abcdef0123"), B.Octets.of_string("The qufc"))) 411 IO.print(lc128(~S.LcSm4Key, ~LC.CrLc.key(~S.LcSm4Key, ~S.LcSm4.key), ~S.LcSm4.encrypt, ~S.LcSm4.decrypt, k16, k16)) 412 IO.print(lc128(~Ca.LcCamelliaKey, ~LC.CrLc.key(~Ca.LcCamelliaKey, ~Ca.LcCamellia.key), ~Ca.LcCamellia.encrypt, ~Ca.LcCamellia.decrypt, k16, k16)) 413 IO.print(lc128(~Sp.LcSerpentKey, ~LC.CrLc.key(~Sp.LcSerpentKey, ~Sp.LcSerpent.key), ~Sp.LcSerpent.encrypt, ~Sp.LcSerpent.decrypt, z16, z16)) 414 IO.print(lc128(~Tf.LcTwofishKey, ~LC.CrLc.key(~Tf.LcTwofishKey, ~Tf.LcTwofish.key), ~Tf.LcTwofish.encrypt, ~Tf.LcTwofish.decrypt, z16, z16)) 415 IO.print(aes_ecb(nk, f4)) 416 IO.print(aes_cbc(nk, hx("000102030405060708090a0b0c0d0e0f"), f4)) 417 IO.print(show(aes_ctr(nk, hx("f0f1f2f3f4f5f6f7f8f9fafbfcfdfeff"), f4))) 418 IO.print(tdes_cbc(hx("0123456789abcdef23456789abcdef01456789abcdef0123"), hx("f69f2445df4f9b17"), B.Octets.of_string("The qufck brown fox jump"))) 419 IO.print(show(des_ctr_pieces(hx("0123456789abcdef"), hx("fffffffffffffffe"), B.Octets.zeros(5n), B.Octets.zeros(14n)))) 420 IO.print(show(rc4(hx("0102030405"), 16n))) 421 IO.print(show(rc4_pieces(hx("0102030405")))) 422 IO.print(show(rc4_drop(hx("0102030405")))) 423 IO.print(cmac(nk, B.Octets.empty())) 424 IO.print(cmac(nk, B.Octets.take(16n, f4))) 425 IO.print(cmac(nk, B.Octets.take(40n, f4))) 426 IO.print(cmac(nk, f4)) 427 IO.print(ccm(~8n, ck, hx("00000003020100a0a1a2a3a4a5"), hx("0001020304050607"), hx("08090a0b0c0d0e0f101112131415161718191a1b1c1d1e"))) 428 IO.print(ccm(~8n, ck, hx("00000004030201a0a1a2a3a4a5"), hx("0001020304050607"), hx("08090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f"))) 429 IO.print(ccm(~8n, ck, hx("00000005040302a0a1a2a3a4a5"), hx("0001020304050607"), hx("08090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20"))) 430 IO.print(B.Octets.hex(CR.CrCrc32.digest(~C.crc32.spec(), B.Octets.of_string("123456789")))) 431 IO.print(B.Octets.hex(CR.CrCrc64.digest(~C.crc64_xz.spec(), B.Octets.of_string("123456789")))) 432 IO.print(crc32_pieces(B.Octets.of_string("1234"), B.Octets.empty(), B.Octets.of_string("56789"))) 433 IO.print(hmac_crc32(B.Octets.of_string("key"), B.Octets.of_string("The quick"), B.Octets.of_string(" brown fox"))) 434 IO.print(hmac_crc64(big(100n), B.Octets.of_string("a message"))) 435 IO.print(hkdf_crc32(B.Octets.of_string("secret"), B.Octets.of_string("salt"), B.Octets.of_string("info"), 10n)) 436 IO.print(hkdf_crc32_max(B.Octets.of_string("secret"))) 437 IO.print(sm4_cbc_big(k16, z16, big(32768n))) 438 IO.print(aes_ctr_big(nk, hx("f0f1f2f3f4f5f6f7f8f9fafbfcfdfeff"), big(32771n))) 439 IO.print(show(Bk.CrBlockCipher.encrypt_with(~X.CmAesKey, ~M.CmBlock, ~A.CrAes.key, ~X.CmAes.encrypt, ~CM.CrBlk128.of_octets, ~CM.CrBlk128.to_octets, B.Octets.zeros(24n), z16))) 440 IO.print(show(Bk.CrBlockCipher.encrypt_with(~X.CmAesKey, ~M.CmBlock, ~A.CrAes.key, ~X.CmAes.encrypt, ~CM.CrBlk128.of_octets, ~CM.CrBlk128.to_octets, z16, B.Octets.zeros(15n)))) 441 IO.print(show(aes_ctr(nk, B.Octets.zeros(12n), f4))) 442 IO.print(aes_cbc(nk, z16, B.Octets.zeros(17n))) 443 IO.print(show(rc4(B.Octets.empty(), 4n))) 444 IO.print(hkdf_crc32(B.Octets.of_string("secret"), B.Octets.empty(), B.Octets.empty(), 1021n)) 445 446 IO.print(sha(~SH.CrSha2.sha256, B.Octets.of_string("abc"))) 447 IO.print(sha(~SH.CrSha2.sha256, B.Octets.of_string("abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"))) 448 IO.print(sha(~SH.CrSha2.sha512, B.Octets.of_string("abc"))) 449 IO.print(sha_pieces3(~SH.CrSha2.init256(), B.Octets.of_string("abcdbcdecdefdefgefgh"), B.Octets.empty(), B.Octets.of_string("fghighijhijkijkljklmklmnlmnomnopnopq"))) 450 IO.print(sha_pieces3(~SH.CrSha2.init512(), B.Octets.of_string("a"), B.Octets.of_string("b"), B.Octets.of_string("c"))) 451 IO.print(sha(~S3.CrSha3.sha3_256, B.Octets.of_string("abc"))) 452 IO.print(sha(~S3.CrSha3.sha3_256, B.Octets.empty())) 453 IO.print(sha(~S3.CrSha3.sha3_256, hx("a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3"))) 454 IO.print(B.Octets.hex(H.CrHash.of_pieces(~S3.CrSha3State, ~S3.CrSha3.init(), ~S3.CrSha3.update, ~S3.CrSha3.final, [hx("a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3"), B.Octets.empty(), hx("a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3a3")]))) 455 IO.print(B.Octets.hex(hmac_sha(~136n, ~S3.CrSha3.sha3_256, hx("4a656665"), hx("7768617420646f2079612077616e7420666f72206e6f7468696e673f")))) 456 IO.print(B.Octets.hex(hmac_sha(~64n, ~SH.CrSha2.sha256, hx("0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b"), hx("4869205468657265")))) 457 IO.print(B.Octets.hex(hmac_sha(~128n, ~SH.CrSha2.sha512, hx("0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b"), hx("4869205468657265")))) 458 IO.print(B.Octets.hex(hmac_sha(~64n, ~SH.CrSha2.sha256, hx("4a656665"), hx("7768617420646f2079612077616e7420666f72206e6f7468696e673f")))) 459 IO.print(B.Octets.hex(hmac_sha(~128n, ~SH.CrSha2.sha512, hx("4a656665"), hx("7768617420646f2079612077616e7420666f72206e6f7468696e673f")))) 460 IO.print(B.Octets.hex(hmac_sha(~64n, ~SH.CrSha2.sha256, hx("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"), hx("dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd")))) 461 IO.print(B.Octets.hex(hmac_sha(~128n, ~SH.CrSha2.sha512, hx("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"), hx("dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd")))) 462 IO.print(B.Octets.hex(hmac_sha(~64n, ~SH.CrSha2.sha256, hx("0102030405060708090a0b0c0d0e0f10111213141516171819"), hx("cdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcd")))) 463 IO.print(B.Octets.hex(hmac_sha(~128n, ~SH.CrSha2.sha512, hx("0102030405060708090a0b0c0d0e0f10111213141516171819"), hx("cdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcd")))) 464 IO.print(B.Octets.hex(B.Octets.take(16n, hmac_sha(~64n, ~SH.CrSha2.sha256, hx("0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c"), hx("546573742057697468205472756e636174696f6e"))))) 465 IO.print(B.Octets.hex(B.Octets.take(16n, hmac_sha(~128n, ~SH.CrSha2.sha512, hx("0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c"), hx("546573742057697468205472756e636174696f6e"))))) 466 IO.print(B.Octets.hex(hmac_sha(~64n, ~SH.CrSha2.sha256, hx("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"), hx("54657374205573696e67204c6172676572205468616e20426c6f636b2d53697a65204b6579202d2048617368204b6579204669727374")))) 467 IO.print(B.Octets.hex(hmac_sha(~128n, ~SH.CrSha2.sha512, hx("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"), hx("54657374205573696e67204c6172676572205468616e20426c6f636b2d53697a65204b6579202d2048617368204b6579204669727374")))) 468 IO.print(B.Octets.hex(hmac_sha(~64n, ~SH.CrSha2.sha256, hx("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"), hx("5468697320697320612074657374207573696e672061206c6172676572207468616e20626c6f636b2d73697a65206b657920616e642061206c6172676572207468616e20626c6f636b2d73697a6520646174612e20546865206b6579206e6565647320746f20626520686173686564206265666f7265206265696e6720757365642062792074686520484d414320616c676f726974686d2e")))) 469 IO.print(B.Octets.hex(hmac_sha(~128n, ~SH.CrSha2.sha512, hx("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"), hx("5468697320697320612074657374207573696e672061206c6172676572207468616e20626c6f636b2d73697a65206b657920616e642061206c6172676572207468616e20626c6f636b2d73697a6520646174612e20546865206b6579206e6565647320746f20626520686173686564206265666f7265206265696e6720757365642062792074686520484d414320616c676f726974686d2e")))) 470 IO.print(hmac_sha256_pieces(hx("4a656665"), B.Octets.of_string("what do ya"), B.Octets.of_string(" want for nothing?"))) 471 IO.print(hkdf_sha256(hx("0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b"), hx("000102030405060708090a0b0c"), hx("f0f1f2f3f4f5f6f7f8f9"), 42n)) 472 IO.print(hkdf_sha256(hx("000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f"), hx("606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeaf"), hx("b0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff"), 82n)) 473 IO.print(hkdf_sha256(hx("0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b"), hx(""), hx(""), 42n)) 474 IO.print(lc128(~Ar.LcAriaKey, ~LC.CrLc.key(~Ar.LcAriaKey, ~Ar.LcAria.key), ~Ar.LcAria.encrypt, ~Ar.LcAria.decrypt, hx("000102030405060708090a0b0c0d0e0f"), hx("00112233445566778899aabbccddeeff"))) 475 IO.print(lc128(~C6.LcCast6Key, ~LC.CrLc.key(~C6.LcCast6Key, ~C6.LcCast6.key), ~C6.LcCast6.encrypt, ~C6.LcCast6.decrypt, hx("2342bb9efa38542c0af75647f29f615d"), z16)) 476 IO.print(lc64(~Bf.LcBlowfishKey, ~LC.CrLc.key(~Bf.LcBlowfishKey, ~Bf.LcBlowfish.key), ~Bf.LcBlowfish.encrypt, ~Bf.LcBlowfish.decrypt, hx("fedcba9876543210"), hx("0123456789abcdef"))) 477 IO.print(lc64(~C5.LcCast5Key, ~LC.CrLc.key(~C5.LcCast5Key, ~C5.LcCast5.key), ~C5.LcCast5.encrypt, ~C5.LcCast5.decrypt, hx("0123456712345678234567893456789a"), hx("0123456789abcdef"))) 478 IO.print(lc64(~Te.LcTeaKey, ~LC.CrLc.key(~Te.LcTeaKey, ~Te.LcTea.key), ~Te.LcTea.encrypt, ~Te.LcTea.decrypt, hx("000102030405060708090a0b0c0d0e0f"), hx("0001020304050607"))) 479 IO.print(lc64(~Xt.LcXteaKey, ~LC.CrLc.key(~Xt.LcXteaKey, ~Xt.LcXtea.key), ~Xt.LcXtea.encrypt, ~Xt.LcXtea.decrypt, hx("000102030405060708090a0b0c0d0e0f"), hx("0001020304050607"))) 480 IO.print(lc64(~Fc.LcFcryptKey, ~LC.CrLc.key(~Fc.LcFcryptKey, ~Fc.LcFcrypt.key), ~Fc.LcFcrypt.encrypt, ~Fc.LcFcrypt.decrypt, hx("114477aadd003366"), hx("123456789abcdef0"))) 481 IO.print(pcbc_fc(hx("3141592653589793"), hx("2718281828459045"), hx("74686973206973206120746573740000"))) 482 IO.print(lrw_aes(hx("4562ac25f828176d4c268414b5680185258e2a05e73e9d03ee5a830ccc094c87"), hx("00000000000000000000000000000001"), hx("30313233343536373839414243444546"))) 483 IO.print(lrw_aes(hx("59704714f557478cd779e80f548879440d48f0b7b15a53ea1caa6b29c2cafbaf"), hx("00000000000000000000000000000002"), hx("30313233343536373839414243444546"))) 484 IO.print(lrw_aes(hx("d82a9134b26a565030fe69e2377f9847cdf90b160c648fb6b00d0d1bae85871f"), hx("00000000000000000000000200000000"), hx("30313233343536373839414243444546"))) 485 IO.print(lrw_aes(hx("f8d476ffd646ee6c2384cb1c77d6195dfef1a9f37bbc8d21a79c21f8cb900289a845348ec8c5b5f126f50e76fefd1b1e"), hx("00000000000000000000000000000001"), hx("30313233343536373839414243444546"))) 486 IO.print(lrw_aes(hx("fb7615b23d80891dd470980bc79584c8b2fb64ce6097878d17fce45a49e830b76e7817e72d5e12d46064047af12f9e0c"), hx("00000000000000000000000200000000"), hx("30313233343536373839414243444546"))) 487 IO.print(cts_aes(hx("636869636b656e207465726979616b69"), z16, hx("4920776f756c64206c696b652074686520"))) 488 IO.print(cts_aes(hx("636869636b656e207465726979616b69"), z16, hx("4920776f756c64206c696b65207468652047656e6572616c20476175277320"))) 489 IO.print(cts_aes(hx("636869636b656e207465726979616b69"), z16, hx("4920776f756c64206c696b65207468652047656e6572616c2047617527732043"))) 490 IO.print(cts_aes(hx("636869636b656e207465726979616b69"), z16, hx("4920776f756c64206c696b65207468652047656e6572616c20476175277320436869636b656e2c20706c656173652c20616e6420776f6e746f6e20736f75702e"))) 491 IO.print(cts_aes(hx("636869636b656e207465726979616b69"), z16, hx("4920776f756c64206c696b6520"))) 492 IO.print(xcbc_aes(hx("000102030405060708090a0b0c0d0e0f"), B.Octets.empty())) 493 IO.print(xcbc_aes(hx("000102030405060708090a0b0c0d0e0f"), hx("000102"))) 494 IO.print(xcbc_aes(hx("000102030405060708090a0b0c0d0e0f"), hx("000102030405060708090a0b0c0d0e0f"))) 495 IO.print(xcbc_aes(hx("000102030405060708090a0b0c0d0e0f"), hx("000102030405060708090a0b0c0d0e0f10111213"))) 496 IO.print(xcbc_aes(hx("000102030405060708090a0b0c0d0e0f"), hx("000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f"))) 497 IO.print(xcbc_aes(hx("000102030405060708090a0b0c0d0e0f"), hx("000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f2021"))) 498 IO.print(xcbc_aes(hx("000102030405060708090a0b0c0d0e0f"), B.Octets.zeros(1000n))) 499 IO.print(vmac_aes(~1n, B.Octets.of_string("abcdefghijklmnop"), B.Octets.of_string("bcdefghi"), B.Octets.empty())) 500 IO.print(vmac_aes(~2n, B.Octets.of_string("abcdefghijklmnop"), B.Octets.of_string("bcdefghi"), B.Octets.empty())) 501 IO.print(vmac_aes(~1n, B.Octets.of_string("abcdefghijklmnop"), B.Octets.of_string("bcdefghi"), B.Octets.of_string("abc"))) 502 IO.print(vmac_aes(~2n, B.Octets.of_string("abcdefghijklmnop"), B.Octets.of_string("bcdefghi"), B.Octets.of_string("abc"))) 503 IO.print(vmac_aes(~1n, B.Octets.of_string("abcdefghijklmnop"), B.Octets.of_string("bcdefghi"), B.Octets.of_string(rep(16n, "abc", "")))) 504 IO.print(vmac_aes(~2n, B.Octets.of_string("abcdefghijklmnop"), B.Octets.of_string("bcdefghi"), B.Octets.of_string(rep(16n, "abc", "")))) 505 IO.print(vmac_aes(~1n, B.Octets.of_string("abcdefghijklmnop"), B.Octets.of_string("bcdefghi"), B.Octets.of_string(rep(100n, "abc", "")))) 506 IO.print(vmac_aes(~2n, B.Octets.of_string("abcdefghijklmnop"), B.Octets.of_string("bcdefghi"), B.Octets.of_string(rep(100n, "abc", "")))) 507 IO.print(hs_hash(~Hs.HsMdState<Hs.HsW4>, ~HM4.HsMd4.init(), ~HM4.HsMd4.update, ~HM4.HsMd4.final, ~HM4.HsMd4.digest, B.Octets.of_string("The quick brown fox "), B.Octets.of_string("jumps over the lazy dog, and then some more bytes to cross a block bound"), B.Octets.of_string("ary."))) 508 IO.print(hs_hash(~Hs.HsMdState<Hs.HsW4>, ~HM5.HsMd5.init(), ~HM5.HsMd5.update, ~HM5.HsMd5.final, ~HM5.HsMd5.digest, B.Octets.of_string("The quick brown fox "), B.Octets.of_string("jumps over the lazy dog, and then some more bytes to cross a block bound"), B.Octets.of_string("ary."))) 509 IO.print(hs_hash(~Hs.HsMdState<Hs.HsW5>, ~HS1.HsSha1.init(), ~HS1.HsSha1.update, ~HS1.HsSha1.final, ~HS1.HsSha1.digest, B.Octets.of_string("The quick brown fox "), B.Octets.of_string("jumps over the lazy dog, and then some more bytes to cross a block bound"), B.Octets.of_string("ary."))) 510 IO.print(hs_hash(~Hs.HsMdState<Hs.HsW5>, ~HRM.HsRipemd160.init(), ~HRM.HsRipemd160.update, ~HRM.HsRipemd160.final, ~HRM.HsRipemd160.digest, B.Octets.of_string("The quick brown fox "), B.Octets.of_string("jumps over the lazy dog, and then some more bytes to cross a block bound"), B.Octets.of_string("ary."))) 511 IO.print(hs_hash(~Hs.HsMdState<Hs.HsW8>, ~HSM.HsSm3.init(), ~HSM.HsSm3.update, ~HSM.HsSm3.final, ~HSM.HsSm3.digest, B.Octets.of_string("The quick brown fox "), B.Octets.of_string("jumps over the lazy dog, and then some more bytes to cross a block bound"), B.Octets.of_string("ary."))) 512 IO.print(hs_hash(~Hs.HsMdState<HST.HsStbCv>, ~HST.HsStreebog.init256(), ~HST.HsStreebog.update, ~HST.HsStreebog.final256, ~HST.HsStreebog.digest256, B.Octets.of_string("The quick brown fox "), B.Octets.of_string("jumps over the lazy dog, and then some more bytes to cross a block bound"), B.Octets.of_string("ary."))) 513 IO.print(hs_hash(~Hs.HsMdState<HST.HsStbCv>, ~HST.HsStreebog.init512(), ~HST.HsStreebog.update, ~HST.HsStreebog.final512, ~HST.HsStreebog.digest512, B.Octets.of_string("The quick brown fox "), B.Octets.of_string("jumps over the lazy dog, and then some more bytes to cross a block bound"), B.Octets.of_string("ary."))) 514 IO.print(hs_hmac(~Hs.HsMdState<Hs.HsW4>, ~64n, ~HM5.HsMd5.init(), ~HM5.HsMd5.update, ~HM5.HsMd5.final, ~HM5.HsMd5.digest, hx("0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b"), B.Octets.of_string("Hi Th"), B.Octets.of_string("ere"))) 515 IO.print(hs_hmac(~Hs.HsMdState<Hs.HsW4>, ~64n, ~HM5.HsMd5.init(), ~HM5.HsMd5.update, ~HM5.HsMd5.final, ~HM5.HsMd5.digest, B.Octets.of_string("Jefe"), B.Octets.of_string("what "), B.Octets.of_string("do ya want for nothing?"))) 516 IO.print(hs_hmac(~Hs.HsMdState<Hs.HsW5>, ~64n, ~HS1.HsSha1.init(), ~HS1.HsSha1.update, ~HS1.HsSha1.final, ~HS1.HsSha1.digest, hx("0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b"), B.Octets.of_string("Hi Th"), B.Octets.of_string("ere"))) 517 IO.print(hs_hmac(~Hs.HsMdState<Hs.HsW5>, ~64n, ~HS1.HsSha1.init(), ~HS1.HsSha1.update, ~HS1.HsSha1.final, ~HS1.HsSha1.digest, B.Octets.of_string("Jefe"), B.Octets.of_string("what "), B.Octets.of_string("do ya want for nothing?"))) 518 IO.print(hs_hmac(~Hs.HsMdState<Hs.HsW4>, ~64n, ~HM4.HsMd4.init(), ~HM4.HsMd4.update, ~HM4.HsMd4.final, ~HM4.HsMd4.digest, hx("000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445"), B.Octets.of_string("The quick brown fox "), B.Octets.of_string("jumps over the lazy dog, and then some more bytes to cross a block bound"))) 519 IO.print(hs_hmac(~Hs.HsMdState<Hs.HsW5>, ~64n, ~HRM.HsRipemd160.init(), ~HRM.HsRipemd160.update, ~HRM.HsRipemd160.final, ~HRM.HsRipemd160.digest, hx("000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445"), B.Octets.of_string("The quick brown fox "), B.Octets.of_string("jumps over the lazy dog, and then some more bytes to cross a block bound"))) 520 IO.print(hs_hmac(~Hs.HsMdState<Hs.HsW8>, ~64n, ~HSM.HsSm3.init(), ~HSM.HsSm3.update, ~HSM.HsSm3.final, ~HSM.HsSm3.digest, hx("000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445"), B.Octets.of_string("The quick brown fox "), B.Octets.of_string("jumps over the lazy dog, and then some more bytes to cross a block bound"))) 521 IO.print(hs_hmac(~Hs.HsMdState<HST.HsStbCv>, ~64n, ~HST.HsStreebog.init256(), ~HST.HsStreebog.update, ~HST.HsStreebog.final256, ~HST.HsStreebog.digest256, hx("000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445"), B.Octets.of_string("The quick brown fox "), B.Octets.of_string("jumps over the lazy dog, and then some more bytes to cross a block bound"))) 522 IO.print(hs_hmac(~Hs.HsMdState<HST.HsStbCv>, ~64n, ~HST.HsStreebog.init512(), ~HST.HsStreebog.update, ~HST.HsStreebog.final512, ~HST.HsStreebog.digest512, hx("000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445"), B.Octets.of_string("The quick brown fox "), B.Octets.of_string("jumps over the lazy dog, and then some more bytes to cross a block bound"))) 523 IO.print(michael_mac(hx("0000000000000000"), B.Octets.empty())) 524 IO.print(michael_mac(hx("82925c1ca1d130b8"), B.Octets.of_string("M"))) 525 IO.print(michael_mac(hx("434721ca40639b3f"), B.Octets.of_string("Mi"))) 526 IO.print(michael_mac(hx("e8f9becae97e5d29"), B.Octets.of_string("Mic"))) 527 IO.print(michael_mac(hx("90038fc6cf13c1db"), B.Octets.of_string("Mich"))) 528 IO.print(michael_mac(hx("d55e100510128986"), B.Octets.of_string("Michael"))) 529 IO.print(michael_mac(hx("00000000000000"), B.Octets.empty())) 530 IO.print(pbkdf2_sha1(B.Octets.of_string("password"), B.Octets.of_string("salt"), 1, 20n)) 531 IO.print(pbkdf2_sha1(B.Octets.of_string("password"), B.Octets.of_string("salt"), 2, 20n)) 532 IO.print(pbkdf2_sha1(B.Octets.of_string("password"), B.Octets.of_string("salt"), 4096, 20n)) 533 IO.print(pbkdf2_sha1(B.Octets.of_string("passwordPASSWORDpassword"), B.Octets.of_string("saltSALTsaltSALTsaltSALTsaltSALTsalt"), 4096, 25n)) 534 IO.print(pbkdf2_sha1(hx("7061737300776f7264"), hx("7361006c74"), 4096, 16n)) 535 IO.print(pbkdf2_sha256(B.Octets.of_string("passwd"), B.Octets.of_string("salt"), 1, 64n)) 536 IO.print(pbkdf2_sha256(B.Octets.of_string("Password"), B.Octets.of_string("NaCl"), 80000, 64n)) 537 IO.print(pbkdf2_sha1(B.Octets.of_string("password"), B.Octets.of_string("salt"), 0, 20n)) 538 IO.print(pbkdf2_md5_kdf(B.Octets.of_string("secret"), B.Octets.of_string("NaCl"), 40n)) 539 IO.print(kbkdf_counter(42n)) 540 IO.print(kbkdf_feedback(42n)) 541 IO.print(kbkdf_short_counter(8161n)) 542 #|69c4e0d86a7b0430d8cdb78070b4c55a 00112233445566778899aabbccddeeff 543 #|8ea2b7ca516745bfeafc49904b496089 00112233445566778899aabbccddeeff 544 #|95f8a5e5dd31d900 8000000000000000 545 #|a826fd8ce53b855f 5468652071756663 546 #|681edf34d206965e86b3e94f536e4246 0123456789abcdeffedcba9876543210 547 #|67673138549669730857065648eabe43 0123456789abcdeffedcba9876543210 548 #|3620b17ae6a993d09618b8768266bae9 00000000000000000000000000000000 549 #|9f589f5cf6122c32b6bfec2f2ae8c35a 00000000000000000000000000000000 550 #|3ad77bb40d7a3660a89ecaf32466ef97f5d3d58503b9699de785895a96fdbaaf43b1cd7f598ece23881b00e3ed0306887b0c785e27e8ad3f8223207104725dd4 6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c81c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417be66c3710 551 #|7649abac8119b246cee98e9b12e9197d5086cb9b507219ee95db113a917678b273bed6b8e3c1743b7116e69e222295163ff1caa1681fac09120eca307586e1a7 6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c81c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417be66c3710 552 #|874d6191b620e3261bef6864990db6ce9806f66b7970fdff8617187bb9fffdff5ae4df3edbd5d35e5b4f09020db03eab1e031dda2fbe03d1792170a0f3009cee 553 #|a5c282bad0de3774becd2e04386b589fb5057d8552fc4336 54686520717566636b2062726f776e20666f78206a756d70 554 #|bc4f694b45d6355359732356f36fde06d5d44f 555 #|b2396305f03dc027ccc3524a0a1118a8 556 #|b2396305f03dc027ccc3524a0a1118a8 557 #|d8729db41882259bee4f825325f5a130 558 #|bb1d6929e95937287fa37d129b756746 accepted 559 #|070a16b46b4d4144f79bdd9dd04a287c accepted 560 #|dfa66747de9ae63030ca32611497c827 accepted 561 #|51f0bebf7e3b9d92fc49741779363cfe accepted 562 #|588c979a61c663d2f066d0c2c0f989806d5f6b61dac38417e8d12cfdf926e0 08090a0b0c0d0e0f101112131415161718191a1b1c1d1e tag mismatch 563 #|72c91a36e135f8cf291ca894085c87e3cc15c439c9e43a3ba091d56e10400916 08090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f tag mismatch 564 #|51b1e5f44a197d1da46b0f8e2d282ae871e838bb64da8596574adaa76fbd9fb0c5 08090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20 tag mismatch 565 #|cbf43926 566 #|995dc9bbdf1939fa 567 #|e3069283 e3069283 568 #|4534cd57 4534cd57 accepted 569 #|194e4372ad2f3f4a 570 #|b397376fd369a94be219 571 #|1020 c824ab370636d8ad 572 #|2761bd68ee073229c87a83da87af1b9b ok 573 #|ee960213d986d3a3c62b718973b132e0 ok 574 #|bad key length 24 575 #|bad block size 15 576 #|bad iv length 12 577 #|not whole blocks 17 not whole blocks 17 578 #|bad key length 0 579 #|bad output length 1021 580 #|ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad 581 #|248d6a61d20638b8e5c026930c3e6039a33ce45964ff2167f6ecedd419db06c1 582 #|ddaf35a193617abacc417349ae20413112e6fa4e89a97ea20a9eeee64b55d39a2192992a274fc1a836ba3c23a3feebbd454d4423643ce80e2a9ac94fa54ca49f 583 #|248d6a61d20638b8e5c026930c3e6039a33ce45964ff2167f6ecedd419db06c1 584 #|ddaf35a193617abacc417349ae20413112e6fa4e89a97ea20a9eeee64b55d39a2192992a274fc1a836ba3c23a3feebbd454d4423643ce80e2a9ac94fa54ca49f 585 #|3a985da74fe225b2045c172d6bd390bd855f086e3e9d525b46bfe24511431532 586 #|a7ffc6f8bf1ed76651c14756a061d662f580ff4de43b49fa82d80a4b80f8434a 587 #|79f38adec5c20307a98ef76e8324afbfd46cfd81b22e3973c65fa1bd9de31787 588 #|79f38adec5c20307a98ef76e8324afbfd46cfd81b22e3973c65fa1bd9de31787 589 #|c7d4072e788877ae3596bbb0da73b887c9171f93095b294ae857fbe2645e1ba5 590 #|b0344c61d8db38535ca8afceaf0bf12b881dc200c9833da726e9376c2e32cff7 591 #|87aa7cdea5ef619d4ff0b4241a1d6cb02379f4e2ce4ec2787ad0b30545e17cdedaa833b7d6b8a702038b274eaea3f4e4be9d914eeb61f1702e696c203a126854 592 #|5bdcc146bf60754e6a042426089575c75a003f089d2739839dec58b964ec3843 593 #|164b7a7bfcf819e2e395fbe73b56e0a387bd64222e831fd610270cd7ea2505549758bf75c05a994a6d034f65f8f0e6fdcaeab1a34d4a6b4b636e070a38bce737 594 #|773ea91e36800e46854db8ebd09181a72959098b3ef8c122d9635514ced565fe 595 #|fa73b0089d56a284efb0f0756c890be9b1b5dbdd8ee81a3655f83e33b2279d39bf3e848279a722c806b485a47e67c807b946a337bee8942674278859e13292fb 596 #|82558a389a443c0ea4cc819899f2083a85f0faa3e578f8077a2e3ff46729665b 597 #|b0ba465637458c6990e5a8c5f61d4af7e576d97ff94b872de76f8050361ee3dba91ca5c11aa25eb4d679275cc5788063a5f19741120c4f2de2adebeb10a298dd 598 #|a3b6167473100ee06e0c796c2955552b 599 #|415fad6271580a531d4179bc891d87a6 600 #|60e431591ee0b67f0d8a26aacbf5b77f8e0bc6213728c5140546040f0ee37f54 601 #|80b24263c7c1a3ebb71493c1dd7be8b49b46d1f41b4aeec1121b013783f8f3526b56d037e05f2598bd0fd2215d6a1e5295e64f73f63f0aec8b915a985d786598 602 #|9b09ffa71b942fcb27635fbcd5b0e944bfdc63644f0713938a7f51535c3a35e2 603 #|e37b6a775dc87dbaa4dfa9f96e5e3ffddebd71f8867289865df5a32d20cdc944b6022cac3c4982b10d5eeb55c3e4de15134676fb6de0446065c97440fa8c6a58 604 #|5bdcc146bf60754e6a042426089575c75a003f089d2739839dec58b964ec3843 accepted 605 #|3cb25f25faacd57a90434f64d0362f2a2d2d0a90cf1a5a4c5db02d56ecc4c5bf34007208d5b887185865 606 #|b11e398dc80327a1c8e7f78c596a49344f012eda2d4efad8a050cc4c19afa97c59045a99cac7827271cb41c65e590e09da3275600c2f09b8367793a9aca3db71cc30c58179ec3e87c14c01d5c1f3434f1d87 607 #|8da4e775a563c18f715f802a063c5a31b8a11f5c5ee1879ec3454e5f3c738d2d9d201395faa4b61a96c8 608 #|d718fbd6ab644c739da95f3be6451778 00112233445566778899aabbccddeeff 609 #|c842a08972b43d20836c91d1b7530f6b 00000000000000000000000000000000 610 #|0aceab0fc6a0a28d 0123456789abcdef 611 #|238b4fe5847e44b2 0123456789abcdef 612 #|6da901760c539dce 0001020304050607 613 #|256004e1f55bc0c7 0001020304050607 614 #|d8ed787477ec0680 123456789abcdef0 615 #|ad5130bd809dc84f08d66ecb10244654 74686973206973206120746573740000 616 #|f1b273cd65a3df5fe95d489254634eb8 30313233343536373839414243444546 617 #|00c82bae95bbcde5274f0769b260e136 30313233343536373839414243444546 618 #|76322183ed8ff182f9596203690e5e01 30313233343536373839414243444546 619 #|bd06b8e1db98899ec498e491cf1c702b 30313233343536373839414243444546 620 #|5b908ec1abdd675f3d698a9553c89ce5 30313233343536373839414243444546 621 #|c6353568f2bf8cb4d8a580362da7ff7f97 4920776f756c64206c696b652074686520 622 #|fc00783e0efdb2c1d445d4c8eff7ed2297687268d6ecccc0c07b25e25ecfe5 4920776f756c64206c696b65207468652047656e6572616c20476175277320 623 #|39312523a78662d5be7fcbcc98ebf5a897687268d6ecccc0c07b25e25ecfe584 4920776f756c64206c696b65207468652047656e6572616c2047617527732043 624 #|97687268d6ecccc0c07b25e25ecfe58439312523a78662d5be7fcbcc98ebf5a84807efe836ee89a526730dbc2f7bc8409dad8bbb96c4cdc03bc103e1a194bbd8 4920776f756c64206c696b65207468652047656e6572616c20476175277320436869636b656e2c20706c656173652c20616e6420776f6e746f6e20736f75702e 625 #|too short 13 too short 13 626 #|75f0251d528ac01c4573dfd584d79f29 627 #|5b376580ae2f19afe7219ceef172756f 628 #|d2a246fa349b68a79998a4394ff7a263 629 #|47f51b4564966215b8985c63055ed308 630 #|f54f0ec8d2b9f3d36807734bd5283fd4 631 #|becbb3bccdb518a30677d5481fb6b4d8 632 #|f0dafee895db30253761103b5d84528f 633 #|2576be1c56d8b81b 634 #|472766c70f74ed23481d6d7de4e80dac 635 #|2d376cf5b1813ce5 636 #|4ee815a06a1d71edd36fc75d51188a42 637 #|e8421f61d573d298 638 #|09f2c80c8e1007a0c12fae19fe4504ae 639 #|4492df6c5cac1bbe 640 #|66438817154850c61d8a412164803bcb 641 #|0e34edd5b6b0d2b2510b41778edbb55f 0e34edd5b6b0d2b2510b41778edbb55f 642 #|3cccac4e66f006326480005db0d2a3e2 3cccac4e66f006326480005db0d2a3e2 643 #|2ea0e6ab3d94c0fd3c194a7494e0abdcc0ccc695 2ea0e6ab3d94c0fd3c194a7494e0abdcc0ccc695 644 #|bd2a22b8c69ba0d6f097f7b49691145fbd037cb1 bd2a22b8c69ba0d6f097f7b49691145fbd037cb1 645 #|2711d8fc556a4f9b99b94f1ac53f99ee36cb0afacb54f9ad4893d2735aee6729 2711d8fc556a4f9b99b94f1ac53f99ee36cb0afacb54f9ad4893d2735aee6729 646 #|3bf13498f37b52a9031a80da3dc2d8fbd415a4d2ae6797edcdd702cf3ffcc475 3bf13498f37b52a9031a80da3dc2d8fbd415a4d2ae6797edcdd702cf3ffcc475 647 #|b55e2710272d1ce45d7f0db9b140e542f5933cdf7a9283833eba0cd9935e29c6264b8c1acc36e817bf6835aef9258c6f5554b72083f61c571c708b40d4f5dc44 b55e2710272d1ce45d7f0db9b140e542f5933cdf7a9283833eba0cd9935e29c6264b8c1acc36e817bf6835aef9258c6f5554b72083f61c571c708b40d4f5dc44 648 #|9294727a3638bb1c13f48ef8158bfc9d 9294727a3638bb1c13f48ef8158bfc9d accepted 649 #|750c783e6ab0b503eaa86e310a5db738 750c783e6ab0b503eaa86e310a5db738 accepted 650 #|b617318655057264e28bc0b6fb378c8ef146be00 b617318655057264e28bc0b6fb378c8ef146be00 accepted 651 #|effcdf6ae5eb2fa2d27416d5f184df9c259a7c79 effcdf6ae5eb2fa2d27416d5f184df9c259a7c79 accepted 652 #|958116dab5453b79b67b3531bdeed436 958116dab5453b79b67b3531bdeed436 accepted 653 #|98ae3a62b8802d3b3ee409fc95f551744a535260 98ae3a62b8802d3b3ee409fc95f551744a535260 accepted 654 #|bef3b0e1dac8f822e28b679f47398e5c2b448534ca13154a3c4bd4a6bce59018 bef3b0e1dac8f822e28b679f47398e5c2b448534ca13154a3c4bd4a6bce59018 accepted 655 #|99b296aed68e48f4c9c301e2dd8d37dab203e2c3008b27ab76f283b67b0b6279 99b296aed68e48f4c9c301e2dd8d37dab203e2c3008b27ab76f283b67b0b6279 accepted 656 #|bf03620da36670fb84857280987a834947cc9e4fa0393078d37a6935ad1bb507b2e42a114da3aabf790451719235b127691acbada691bebb4140741ae3b55a87 bf03620da36670fb84857280987a834947cc9e4fa0393078d37a6935ad1bb507b2e42a114da3aabf790451719235b127691acbada691bebb4140741ae3b55a87 accepted 657 #|82925c1ca1d130b8 accepted refused 658 #|434721ca40639b3f accepted refused 659 #|e8f9becae97e5d29 accepted refused 660 #|90038fc6cf13c1db accepted refused 661 #|d55e100510128986 accepted refused 662 #|0a942b124ecaa546 accepted refused 663 #|bad key length 7 664 #|0c60c80f961f0e71f3a9b524af6012062fe037a6 665 #|ea6c014dc72d6f8ccd1ed92ace1d41f0d8de8957 666 #|4b007901b765489abead49d926f721d065a429c1 667 #|3d2eec4fe41c849b80c8d83662c0e44a8b291a964cf2f07038 668 #|56fa6aa75548099dcc37d7f03425e0c3 669 #|55ac046e56e3089fec1691c22544b605f94185216dde0465e68b9d57c20dacbc49ca9cccf179b645991664b39d77ef317c71b845b1e30bd509112041d3a19783 670 #|4ddcd8f60b98be21830cee5ef22701f9641a4418d04c0414aeff08876b34ab56a1d425a1225833549adb841b51c9b3176a272bdebba1d078478f62b397f33c8d 671 #|too short 0 672 #|da3ca5acd6e25d1847064b1c7724b2e1dfb7cf1f6d13a180a8654e6f0ab45d9027de54dfb40426ce 673 #|3748e2da7405337c57e05e37f5da94b21b7cfd8404e6b9b5d8a08abfe82c4abad5089119ffc50b8920ca 674 #|607e0f6e9d30f9a79287a0fb12554994d92c3739a360dfdae3255c18b18bf3fcb417fecb5457dde6ef46 675 #|bad output length 8161