import Substitute from "@fluffy-spoon/substitute" ; import { PlatformUtilsService } from "jslib-common/abstractions/platformUtils.service" ; import { WebCryptoFunctionService } from "jslib-common/services/webCryptoFunction.service" ; import { Utils } from "jslib-common/misc/utils" ; import { SymmetricCryptoKey } from "jslib-common/models/domain/symmetricCryptoKey" ; const RsaPublicKey = "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAl0Vawl/toXzkEvB82FEtqHP" + "4xlU2ab/v0crqIfXfIoWF/XXdHGIdrZeilnRXPPJT1B9dTsasttEZNnua/0Rek/cjNDHtzT52irfoZYS7X6HNIfOi54Q+egP" + "RQ1H7iNHVZz3K8Db9GCSKPeC8MbW6gVCzb15esCe1gGzg6wkMuWYDFYPoh/oBqcIqrGah7firqB1nDedzEjw32heP2DAffVN" + "084iTDjiWrJNUxBJ2pDD5Z9dT3MzQ2s09ew1yMWK2z37rT3YerC7OgEDmo3WYo3xL3qYJznu3EO2nmrYjiRa40wKSjxsTlUc" + "xDF+F0uMW8oR9EMUHgepdepfAtLsSAQIDAQAB" ; const RsaPrivateKey = "MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQCXRVrCX+2hfOQS8Hz" + "YUS2oc/jGVTZpv+/Ryuoh9d8ihYX9dd0cYh2tl6KWdFc88lPUH11Oxqy20Rk2e5r/RF6T9yM0Me3NPnaKt+hlhLtfoc0h86L" + "nhD56A9FDUfuI0dVnPcrwNv0YJIo94LwxtbqBULNvXl6wJ7WAbODrCQy5ZgMVg+iH+gGpwiqsZqHt+KuoHWcN53MSPDfaF4/" + "YMB99U3TziJMOOJask1TEEnakMPln11PczNDazT17DXIxYrbPfutPdh6sLs6AQOajdZijfEvepgnOe7cQ7aeatiOJFrjTApK" + "PGxOVRzEMX4XS4xbyhH0QxQeB6l16l8C0uxIBAgMBAAECggEASaWfeVDA3cVzOPFSpvJm20OTE+R6uGOU+7vh36TX/POq92q" + "Buwbd0h0oMD32FxsXywd2IxtBDUSiFM9699qufTVuM0Q3tZw6lHDTOVG08+tPdr8qSbMtw7PGFxN79fHLBxejjO4IrM9lapj" + "WpxEF+11x7r+wM+0xRZQ8sNFYG46aPfIaty4BGbL0I2DQ2y8I57iBCAy69eht59NLMm27fRWGJIWCuBIjlpfzET1j2HLXUIh" + "5bTBNzqaN039WH49HczGE3mQKVEJZc/efk3HaVd0a1Sjzyn0QY+N1jtZN3jTRbuDWA1AknkX1LX/0tUhuS3/7C3ejHxjw4Dk" + "1ZLo5/QKBgQDIWvqFn0+IKRSu6Ua2hDsufIHHUNLelbfLUMmFthxabcUn4zlvIscJO00Tq/ezopSRRvbGiqnxjv/mYxucvOU" + "BeZtlus0Q9RTACBtw9TGoNTmQbEunJ2FOSlqbQxkBBAjgGEppRPt30iGj/VjAhCATq2MYOa/X4dVR51BqQAFIEwKBgQDBSIf" + "TFKC/hDk6FKZlgwvupWYJyU9RkyfstPErZFmzoKhPkQ3YORo2oeAYmVUbS9I2iIYpYpYQJHX8jMuCbCz4ONxTCuSIXYQYUcU" + "q4PglCKp31xBAE6TN8SvhfME9/MvuDssnQinAHuF0GDAhF646T3LLS1not6Vszv7brwSoGwKBgQC88v/8cGfi80ssQZeMnVv" + "q1UTXIeQcQnoY5lGHJl3K8mbS3TnXE6c9j417Fdz+rj8KWzBzwWXQB5pSPflWcdZO886Xu/mVGmy9RWgLuVFhXwCwsVEPjNX" + "5ramRb0/vY0yzenUCninBsIxFSbIfrPtLUYCc4hpxr+sr2Mg/y6jpvQKBgBezMRRs3xkcuXepuI2R+BCXL1/b02IJTUf1F+1" + "eLLGd7YV0H+J3fgNc7gGWK51hOrF9JBZHBGeOUPlaukmPwiPdtQZpu4QNE3l37VlIpKTF30E6mb+BqR+nht3rUjarnMXgAoE" + "Z18y6/KIjpSMpqC92Nnk/EBM9EYe6Cf4eA9ApAoGAeqEUg46UTlJySkBKURGpIs3v1kkf5I0X8DnOhwb+HPxNaiEdmO7ckm8" + "+tPVgppLcG0+tMdLjigFQiDUQk2y3WjyxP5ZvXu7U96jaJRI8PFMoE06WeVYcdIzrID2HvqH+w0UQJFrLJ/0Mn4stFAEzXKZ" + "BokBGnjFnTnKcs7nv/O8=" ; const Sha1Mac = "4d4c223f95dc577b665ec4ccbcb680b80a397038" ; const Sha256Mac = "6be3caa84922e12aaaaa2f16c40d44433bb081ef323db584eb616333ab4e874f" ; const Sha512Mac = "21910e341fa12106ca35758a2285374509326c9fbe0bd64e7b99c898f841dc948c58ce66d3504d8883c" + "5ea7817a0b7c5d4d9b00364ccd214669131fc17fe4aca" ; describe ( "WebCrypto Function Service" , ( ) => { describe ( "pbkdf2" , ( ) => { const regular256Key = "pj9prw/OHPleXI6bRdmlaD+saJS4awrMiQsQiDjeu2I=" ; const utf8256Key = "yqvoFXgMRmHR3QPYr5pyR4uVuoHkltv9aHUP63p8n7I=" ; const unicode256Key = "ZdeOata6xoRpB4DLp8zHhXz5kLmkWtX5pd+TdRH8w8w=" ; const regular512Key = "liTi/Ke8LPU1Qv+Vl7NGEVt/XMbsBVJ2kQxtVG/Z1/JFHFKQW3ZkI81qVlwTiCpb+cFXzs+57" + "eyhhx5wfKo5Cg==" ; const utf8512Key = "df0KdvIBeCzD/kyXptwQohaqUa4e7IyFUyhFQjXCANu5T+scq55hCcE4dG4T/MhAk2exw8j7ixRN" + "zXANiVZpnw==" ; const unicode512Key = "FE+AnUJaxv8jh+zUDtZz4mjjcYk0/PZDZm+SLJe3XtxtnpdqqpblX6JjuMZt/dYYNMOrb2+mD" + "L3FiQDTROh1lg==" ; testPbkdf2 ( "sha256" , regular256Key , utf8256Key , unicode256Key ) ; testPbkdf2 ( "sha512" , regular512Key , utf8512Key , unicode512Key ) ; } ) ; describe ( "hkdf" , ( ) => { const regular256Key = "qBUmEYtwTwwGPuw/z6bs/qYXXYNUlocFlyAuuANI8Pw=" ; const utf8256Key = "6DfJwW1R3txgiZKkIFTvVAb7qVlG7lKcmJGJoxR2GBU=" ; const unicode256Key = "gejGI82xthA+nKtKmIh82kjw+ttHr+ODsUoGdu5sf0A=" ; const regular512Key = "xe5cIG6ZfwGmb1FvsOedM0XKOm21myZkjL/eDeKIqqM=" ; const utf8512Key = "XQMVBnxVEhlvjSFDQc77j5GDE9aorvbS0vKnjhRg0LY=" ; const unicode512Key = "148GImrTbrjaGAe/iWEpclINM8Ehhko+9lB14+52lqc=" ; testHkdf ( "sha256" , regular256Key , utf8256Key , unicode256Key ) ; testHkdf ( "sha512" , regular512Key , utf8512Key , unicode512Key ) ; } ) ; describe ( "hkdfExpand" , ( ) => { const prk16Byte = "criAmKtfzxanbgea5/kelQ==" ; const prk32Byte = "F5h4KdYQnIVH4rKH0P9CZb1GrR4n16/sJrS0PsQEn0Y=" ; const prk64Byte = "ssBK0mRG17VHdtsgt8yo4v25CRNpauH+0r2fwY/E9rLyaFBAOMbIeTry+" + "gUJ28p8y+hFh3EI9pcrEWaNvFYonQ==" ; testHkdfExpand ( "sha256" , prk32Byte , 32 , "BnIqJlfnHm0e/2iB/15cbHyR19ARPIcWRp4oNS22CD8=" ) ; testHkdfExpand ( "sha256" , prk32Byte , 64 , "BnIqJlfnHm0e/2iB/15cbHyR19ARPIcWRp4oNS22CD9BV+" + "/queOZenPNkDhmlVyL2WZ3OSU5+7ISNF5NhNfvZA==" ) ; testHkdfExpand ( "sha512" , prk64Byte , 32 , "uLWbMWodSBms5uGJ5WTRTesyW+MD7nlpCZvagvIRXlk=" ) ; testHkdfExpand ( "sha512" , prk64Byte , 64 , "uLWbMWodSBms5uGJ5WTRTesyW+MD7nlpCZvagvIRXlkY5Pv0sB+" + "MqvaopmkC6sD/j89zDwTV9Ib2fpucUydO8w==" ) ; it ( "should fail with prk too small" , async ( ) => { const cryptoFunctionService = getWebCryptoFunctionService ( ) ; const f = cryptoFunctionService . hkdfExpand ( Utils . fromB64ToArray ( prk16Byte ) , "info" , 32 , "sha256" ) ; await expectAsync ( f ) . toBeRejectedWith ( new Error ( "prk is too small." ) ) ; } ) ; it ( "should fail with outputByteSize is too large" , async ( ) => { const cryptoFunctionService = getWebCryptoFunctionService ( ) ; const f = cryptoFunctionService . hkdfExpand ( Utils . fromB64ToArray ( prk32Byte ) , "info" , 8161 , "sha256" ) ; await expectAsync ( f ) . toBeRejectedWith ( new Error ( "outputByteSize is too large." ) ) ; } ) ; } ) ; describe ( "hash" , ( ) => { const regular1Hash = "2a241604fb921fad12bf877282457268e1dccb70" ; const utf81Hash = "85672798dc5831e96d6c48655d3d39365a9c88b6" ; const unicode1Hash = "39c975935054a3efc805a9709b60763a823a6ad4" ; const regular256Hash = "2b8e96031d352a8655d733d7a930b5ffbea69dc25cf65c7bca7dd946278908b2" ; const utf8256Hash = "25fe8440f5b01ed113b0a0e38e721b126d2f3f77a67518c4a04fcde4e33eeb9d" ; const unicode256Hash = "adc1c0c2afd6e92cefdf703f9b6eb2c38e0d6d1a040c83f8505c561fea58852e" ; const regular512Hash = "c15cf11d43bde333647e3f559ec4193bb2edeaa0e8b902772f514cdf3f785a3f49a6e02a4b87b3" + "b47523271ad45b7e0aebb5cdcc1bc54815d256eb5dcb80da9d" ; const utf8512Hash = "035c31a877a291af09ed2d3a1a293e69c3e079ea2cecc00211f35e6bce10474ca3ad6e30b59e26118" + "37463f20969c5bc95282965a051a88f8cdf2e166549fcdd" ; const unicode512Hash = "2b16a5561af8ad6fe414cc103fc8036492e1fc6d9aabe1b655497054f760fe0e34c5d100ac773d" + "9f3030438284f22dbfa20cb2e9b019f2c98dfe38ce1ef41bae" ; const regularMd5 = "5eceffa53a5fd58c44134211e2c5f522" ; const utf8Md5 = "3abc9433c09551b939c80aa0aa3174e1" ; const unicodeMd5 = "85ae134072c8d81257933f7045ba17ca" ; testHash ( "sha1" , regular1Hash , utf81Hash , unicode1Hash ) ; testHash ( "sha256" , regular256Hash , utf8256Hash , unicode256Hash ) ; testHash ( "sha512" , regular512Hash , utf8512Hash , unicode512Hash ) ; testHash ( "md5" , regularMd5 , utf8Md5 , unicodeMd5 ) ; } ) ; describe ( "hmac" , ( ) => { testHmac ( "sha1" , Sha1Mac ) ; testHmac ( "sha256" , Sha256Mac ) ; testHmac ( "sha512" , Sha512Mac ) ; } ) ; describe ( "compare" , ( ) => { it ( "should successfully compare two of the same values" , async ( ) => { const cryptoFunctionService = getWebCryptoFunctionService ( ) ; const a = new Uint8Array ( 2 ) ; a [ 0 ] = 1 ; a [ 1 ] = 2 ; const equal = await cryptoFunctionService . compare ( a . buffer , a . buffer ) ; expect ( equal ) . toBe ( true ) ; } ) ; it ( "should successfully compare two different values of the same length" , async ( ) => { const cryptoFunctionService = getWebCryptoFunctionService ( ) ; const a = new Uint8Array ( 2 ) ; a [ 0 ] = 1 ; a [ 1 ] = 2 ; const b = new Uint8Array ( 2 ) ; b [ 0 ] = 3 ; b [ 1 ] = 4 ; const equal = await cryptoFunctionService . compare ( a . buffer , b . buffer ) ; expect ( equal ) . toBe ( false ) ; } ) ; it ( "should successfully compare two different values of different lengths" , async ( ) => { const cryptoFunctionService = getWebCryptoFunctionService ( ) ; const a = new Uint8Array ( 2 ) ; a [ 0 ] = 1 ; a [ 1 ] = 2 ; const b = new Uint8Array ( 2 ) ; b [ 0 ] = 3 ; const equal = await cryptoFunctionService . compare ( a . buffer , b . buffer ) ; expect ( equal ) . toBe ( false ) ; } ) ; } ) ; describe ( "hmacFast" , ( ) => { testHmacFast ( "sha1" , Sha1Mac ) ; testHmacFast ( "sha256" , Sha256Mac ) ; testHmacFast ( "sha512" , Sha512Mac ) ; } ) ; describe ( "compareFast" , ( ) => { it ( "should successfully compare two of the same values" , async ( ) => { const cryptoFunctionService = getWebCryptoFunctionService ( ) ; const a = new Uint8Array ( 2 ) ; a [ 0 ] = 1 ; a [ 1 ] = 2 ; const aByteString = Utils . fromBufferToByteString ( a . buffer ) ; const equal = await cryptoFunctionService . compareFast ( aByteString , aByteString ) ; expect ( equal ) . toBe ( true ) ; } ) ; it ( "should successfully compare two different values of the same length" , async ( ) => { const cryptoFunctionService = getWebCryptoFunctionService ( ) ; const a = new Uint8Array ( 2 ) ; a [ 0 ] = 1 ; a [ 1 ] = 2 ; const aByteString = Utils . fromBufferToByteString ( a . buffer ) ; const b = new Uint8Array ( 2 ) ; b [ 0 ] = 3 ; b [ 1 ] = 4 ; const bByteString = Utils . fromBufferToByteString ( b . buffer ) ; const equal = await cryptoFunctionService . compareFast ( aByteString , bByteString ) ; expect ( equal ) . toBe ( false ) ; } ) ; it ( "should successfully compare two different values of different lengths" , async ( ) => { const cryptoFunctionService = getWebCryptoFunctionService ( ) ; const a = new Uint8Array ( 2 ) ; a [ 0 ] = 1 ; a [ 1 ] = 2 ; const aByteString = Utils . fromBufferToByteString ( a . buffer ) ; const b = new Uint8Array ( 2 ) ; b [ 0 ] = 3 ; const bByteString = Utils . fromBufferToByteString ( b . buffer ) ; const equal = await cryptoFunctionService . compareFast ( aByteString , bByteString ) ; expect ( equal ) . toBe ( false ) ; } ) ; } ) ; describe ( "aesEncrypt" , ( ) => { it ( "should successfully encrypt data" , async ( ) => { const cryptoFunctionService = getWebCryptoFunctionService ( ) ; const iv = makeStaticByteArray ( 16 ) ; const key = makeStaticByteArray ( 32 ) ; const data = Utils . fromUtf8ToArray ( "EncryptMe!" ) ; const encValue = await cryptoFunctionService . aesEncrypt ( data . buffer , iv . buffer , key . buffer ) ; expect ( Utils . fromBufferToB64 ( encValue ) ) . toBe ( "ByUF8vhyX4ddU9gcooznwA==" ) ; } ) ; it ( "should successfully encrypt and then decrypt data fast" , async ( ) => { const cryptoFunctionService = getWebCryptoFunctionService ( ) ; const iv = makeStaticByteArray ( 16 ) ; const key = makeStaticByteArray ( 32 ) ; const value = "EncryptMe!" ; const data = Utils . fromUtf8ToArray ( value ) ; const encValue = await cryptoFunctionService . aesEncrypt ( data . buffer , iv . buffer , key . buffer ) ; const encData = Utils . fromBufferToB64 ( encValue ) ; const b64Iv = Utils . fromBufferToB64 ( iv . buffer ) ; const symKey = new SymmetricCryptoKey ( key . buffer ) ; const params = cryptoFunctionService . aesDecryptFastParameters ( encData , b64Iv , null , symKey ) ; const decValue = await cryptoFunctionService . aesDecryptFast ( params ) ; expect ( decValue ) . toBe ( value ) ; } ) ; it ( "should successfully encrypt and then decrypt data" , async ( ) => { const cryptoFunctionService = getWebCryptoFunctionService ( ) ; const iv = makeStaticByteArray ( 16 ) ; const key = makeStaticByteArray ( 32 ) ; const value = "EncryptMe!" ; const data = Utils . fromUtf8ToArray ( value ) ; const encValue = await cryptoFunctionService . aesEncrypt ( data . buffer , iv . buffer , key . buffer ) ; const decValue = await cryptoFunctionService . aesDecrypt ( encValue , iv . buffer , key . buffer ) ; expect ( Utils . fromBufferToUtf8 ( decValue ) ) . toBe ( value ) ; } ) ; } ) ; describe ( "aesDecryptFast" , ( ) => { it ( "should successfully decrypt data" , async ( ) => { const cryptoFunctionService = getWebCryptoFunctionService ( ) ; const iv = Utils . fromBufferToB64 ( makeStaticByteArray ( 16 ) . buffer ) ; const symKey = new SymmetricCryptoKey ( makeStaticByteArray ( 32 ) . buffer ) ; const data = "ByUF8vhyX4ddU9gcooznwA==" ; const params = cryptoFunctionService . aesDecryptFastParameters ( data , iv , null , symKey ) ; const decValue = await cryptoFunctionService . aesDecryptFast ( params ) ; expect ( decValue ) . toBe ( "EncryptMe!" ) ; } ) ; } ) ; describe ( "aesDecrypt" , ( ) => { it ( "should successfully decrypt data" , async ( ) => { const cryptoFunctionService = getWebCryptoFunctionService ( ) ; const iv = makeStaticByteArray ( 16 ) ; const key = makeStaticByteArray ( 32 ) ; const data = Utils . fromB64ToArray ( "ByUF8vhyX4ddU9gcooznwA==" ) ; const decValue = await cryptoFunctionService . aesDecrypt ( data . buffer , iv . buffer , key . buffer ) ; expect ( Utils . fromBufferToUtf8 ( decValue ) ) . toBe ( "EncryptMe!" ) ; } ) ; } ) ; describe ( "rsaEncrypt" , ( ) => { it ( "should successfully encrypt and then decrypt data" , async ( ) => { const cryptoFunctionService = getWebCryptoFunctionService ( ) ; const pubKey = Utils . fromB64ToArray ( RsaPublicKey ) ; const privKey = Utils . fromB64ToArray ( RsaPrivateKey ) ; const value = "EncryptMe!" ; const data = Utils . fromUtf8ToArray ( value ) ; const encValue = await cryptoFunctionService . rsaEncrypt ( data . buffer , pubKey . buffer , "sha1" ) ; const decValue = await cryptoFunctionService . rsaDecrypt ( encValue , privKey . buffer , "sha1" ) ; expect ( Utils . fromBufferToUtf8 ( decValue ) ) . toBe ( value ) ; } ) ; } ) ; describe ( "rsaDecrypt" , ( ) => { it ( "should successfully decrypt data" , async ( ) => { const cryptoFunctionService = getWebCryptoFunctionService ( ) ; const privKey = Utils . fromB64ToArray ( RsaPrivateKey ) ; const data = Utils . fromB64ToArray ( "A1/p8BQzN9UrbdYxUY2Va5+kPLyfZXF9JsZrjeEXcaclsnHurdxVAJcnbEqYMP3UXV" + "4YAS/mpf+Rxe6/X0WS1boQdA0MAHSgx95hIlAraZYpiMLLiJRKeo2u8YivCdTM9V5vuAEJwf9Tof/qFsFci3sApdbATkorCT" + "zFOIEPF2S1zgperEP23M01mr4dWVdYN18B32YF67xdJHMbFhp5dkQwv9CmscoWq7OE5HIfOb+JAh7BEZb+CmKhM3yWJvoR/D" + "/5jcercUtK2o+XrzNrL4UQ7yLZcFz6Bfwb/j6ICYvqd/YJwXNE6dwlL57OfwJyCdw2rRYf0/qI00t9u8Iitw==" ) ; const decValue = await cryptoFunctionService . rsaDecrypt ( data . buffer , privKey . buffer , "sha1" ) ; expect ( Utils . fromBufferToUtf8 ( decValue ) ) . toBe ( "EncryptMe!" ) ; } ) ; } ) ; describe ( "rsaExtractPublicKey" , ( ) => { it ( "should successfully extract key" , async ( ) => { const cryptoFunctionService = getWebCryptoFunctionService ( ) ; const privKey = Utils . fromB64ToArray ( RsaPrivateKey ) ; const publicKey = await cryptoFunctionService . rsaExtractPublicKey ( privKey . buffer ) ; expect ( Utils . fromBufferToB64 ( publicKey ) ) . toBe ( RsaPublicKey ) ; } ) ; } ) ; describe ( "rsaGenerateKeyPair" , ( ) => { testRsaGenerateKeyPair ( 1024 ) ; testRsaGenerateKeyPair ( 2048 ) ; } ) ; describe ( "randomBytes" , ( ) => { it ( "should make a value of the correct length" , async ( ) => { const cryptoFunctionService = getWebCryptoFunctionService ( ) ; const randomData = await cryptoFunctionService . randomBytes ( 16 ) ; expect ( randomData . byteLength ) . toBe ( 16 ) ; } ) ; it ( "should not make the same value twice" , async ( ) => { const cryptoFunctionService = getWebCryptoFunctionService ( ) ; const randomData = await cryptoFunctionService . randomBytes ( 16 ) ; const randomData2 = await cryptoFunctionService . randomBytes ( 16 ) ; expect ( randomData . byteLength === randomData2 . byteLength && randomData !== randomData2 ) . toBeTruthy ( ) ; } ) ; } ) ; } ) ; function testPbkdf2 ( algorithm , regularKey , utf8Key , unicodeKey ) { const regularEmail = "user@example.com" ; const utf8Email = "üser@example.com" ; const regularPassword = "password" ; const utf8Password = "pǻssword" ; const unicodePassword = "😀password🙏" ; it ( "should create valid " + algorithm + " key from regular input" , async ( ) => { const cryptoFunctionService = getWebCryptoFunctionService ( ) ; const key = await cryptoFunctionService . pbkdf2 ( regularPassword , regularEmail , algorithm , 5000 ) ; expect ( Utils . fromBufferToB64 ( key ) ) . toBe ( regularKey ) ; } ) ; it ( "should create valid " + algorithm + " key from utf8 input" , async ( ) => { const cryptoFunctionService = getWebCryptoFunctionService ( ) ; const key = await cryptoFunctionService . pbkdf2 ( utf8Password , utf8Email , algorithm , 5000 ) ; expect ( Utils . fromBufferToB64 ( key ) ) . toBe ( utf8Key ) ; } ) ; it ( "should create valid " + algorithm + " key from unicode input" , async ( ) => { const cryptoFunctionService = getWebCryptoFunctionService ( ) ; const key = await cryptoFunctionService . pbkdf2 ( unicodePassword , regularEmail , algorithm , 5000 ) ; expect ( Utils . fromBufferToB64 ( key ) ) . toBe ( unicodeKey ) ; } ) ; it ( "should create valid " + algorithm + " key from array buffer input" , async ( ) => { const cryptoFunctionService = getWebCryptoFunctionService ( ) ; const key = await cryptoFunctionService . pbkdf2 ( Utils . fromUtf8ToArray ( regularPassword ) . buffer , Utils . fromUtf8ToArray ( regularEmail ) . buffer , algorithm , 5000 ) ; expect ( Utils . fromBufferToB64 ( key ) ) . toBe ( regularKey ) ; } ) ; } function testHkdf ( algorithm , regularKey , utf8Key , unicodeKey ) { const ikm = Utils . fromB64ToArray ( "criAmKtfzxanbgea5/kelQ==" ) ; const regularSalt = "salt" ; const utf8Salt = "üser_salt" ; const unicodeSalt = "😀salt🙏" ; const regularInfo = "info" ; const utf8Info = "üser_info" ; const unicodeInfo = "😀info🙏" ; it ( "should create valid " + algorithm + " key from regular input" , async ( ) => { const cryptoFunctionService = getWebCryptoFunctionService ( ) ; const key = await cryptoFunctionService . hkdf ( ikm , regularSalt , regularInfo , 32 , algorithm ) ; expect ( Utils . fromBufferToB64 ( key ) ) . toBe ( regularKey ) ; } ) ; it ( "should create valid " + algorithm + " key from utf8 input" , async ( ) => { const cryptoFunctionService = getWebCryptoFunctionService ( ) ; const key = await cryptoFunctionService . hkdf ( ikm , utf8Salt , utf8Info , 32 , algorithm ) ; expect ( Utils . fromBufferToB64 ( key ) ) . toBe ( utf8Key ) ; } ) ; it ( "should create valid " + algorithm + " key from unicode input" , async ( ) => { const cryptoFunctionService = getWebCryptoFunctionService ( ) ; const key = await cryptoFunctionService . hkdf ( ikm , unicodeSalt , unicodeInfo , 32 , algorithm ) ; expect ( Utils . fromBufferToB64 ( key ) ) . toBe ( unicodeKey ) ; } ) ; it ( "should create valid " + algorithm + " key from array buffer input" , async ( ) => { const cryptoFunctionService = getWebCryptoFunctionService ( ) ; const key = await cryptoFunctionService . hkdf ( ikm , Utils . fromUtf8ToArray ( regularSalt ) . buffer , Utils . fromUtf8ToArray ( regularInfo ) . buffer , 32 , algorithm ) ; expect ( Utils . fromBufferToB64 ( key ) ) . toBe ( regularKey ) ; } ) ; } function testHkdfExpand ( algorithm , b64prk , outputByteSize , b64ExpectedOkm ) { const info = "info" ; it ( "should create valid " + algorithm + " " + outputByteSize + " byte okm" , async ( ) => { const cryptoFunctionService = getWebCryptoFunctionService ( ) ; const okm = await cryptoFunctionService . hkdfExpand ( Utils . fromB64ToArray ( b64prk ) , info , outputByteSize , algorithm ) ; expect ( Utils . fromBufferToB64 ( okm ) ) . toBe ( b64ExpectedOkm ) ; } ) ; } function testHash ( algorithm , regularHash , utf8Hash , unicodeHash ) { const regularValue = "HashMe!!" ; const utf8Value = "HǻshMe!!" ; const unicodeValue = "😀HashMe!!!🙏" ; it ( "should create valid " + algorithm + " hash from regular input" , async ( ) => { const cryptoFunctionService = getWebCryptoFunctionService ( ) ; const hash = await cryptoFunctionService . hash ( regularValue , algorithm ) ; expect ( Utils . fromBufferToHex ( hash ) ) . toBe ( regularHash ) ; } ) ; it ( "should create valid " + algorithm + " hash from utf8 input" , async ( ) => { const cryptoFunctionService = getWebCryptoFunctionService ( ) ; const hash = await cryptoFunctionService . hash ( utf8Value , algorithm ) ; expect ( Utils . fromBufferToHex ( hash ) ) . toBe ( utf8Hash ) ; } ) ; it ( "should create valid " + algorithm + " hash from unicode input" , async ( ) => { const cryptoFunctionService = getWebCryptoFunctionService ( ) ; const hash = await cryptoFunctionService . hash ( unicodeValue , algorithm ) ; expect ( Utils . fromBufferToHex ( hash ) ) . toBe ( unicodeHash ) ; } ) ; it ( "should create valid " + algorithm + " hash from array buffer input" , async ( ) => { const cryptoFunctionService = getWebCryptoFunctionService ( ) ; const hash = await cryptoFunctionService . hash ( Utils . fromUtf8ToArray ( regularValue ) . buffer , algorithm ) ; expect ( Utils . fromBufferToHex ( hash ) ) . toBe ( regularHash ) ; } ) ; } function testHmac ( algorithm , mac ) { it ( "should create valid " + algorithm + " hmac" , async ( ) => { const cryptoFunctionService = getWebCryptoFunctionService ( ) ; const computedMac = await cryptoFunctionService . hmac ( Utils . fromUtf8ToArray ( "SignMe!!" ) . buffer , Utils . fromUtf8ToArray ( "secretkey" ) . buffer , algorithm ) ; expect ( Utils . fromBufferToHex ( computedMac ) ) . toBe ( mac ) ; } ) ; } function testHmacFast ( algorithm , mac ) { it ( "should create valid " + algorithm + " hmac" , async ( ) => { const cryptoFunctionService = getWebCryptoFunctionService ( ) ; const keyByteString = Utils . fromBufferToByteString ( Utils . fromUtf8ToArray ( "secretkey" ) . buffer ) ; const dataByteString = Utils . fromBufferToByteString ( Utils . fromUtf8ToArray ( "SignMe!!" ) . buffer ) ; const computedMac = await cryptoFunctionService . hmacFast ( dataByteString , keyByteString , algorithm ) ; expect ( Utils . fromBufferToHex ( Utils . fromByteStringToArray ( computedMac ) . buffer ) ) . toBe ( mac ) ; } ) ; } function testRsaGenerateKeyPair ( length ) { it ( "should successfully generate a " + length + " bit key pair" , async ( ) => { const cryptoFunctionService = getWebCryptoFunctionService ( ) ; const keyPair = await cryptoFunctionService . rsaGenerateKeyPair ( length ) ; expect ( keyPair [ 0 ] == null || keyPair [ 1 ] == null ) . toBe ( false ) ; const publicKey = await cryptoFunctionService . rsaExtractPublicKey ( keyPair [ 1 ] ) ; expect ( Utils . fromBufferToB64 ( keyPair [ 0 ] ) ) . toBe ( Utils . fromBufferToB64 ( publicKey ) ) ; } , 30000 ) ; } function getWebCryptoFunctionService ( ) { const platformUtilsMock = Substitute . for < PlatformUtilsService > ( ) ; platformUtilsMock . isEdge ( ) . mimicks ( ( ) => navigator . userAgent . indexOf ( " Edg/" ) !== - 1 ) ; platformUtilsMock . isIE ( ) . mimicks ( ( ) => navigator . userAgent . indexOf ( " Edg/" ) === - 1 && navigator . userAgent . indexOf ( " Trident/" ) !== - 1 ) ; return new WebCryptoFunctionService ( window , platformUtilsMock ) ; } function makeStaticByteArray ( length ) { const arr = new Uint8Array ( length ) ; for ( let i = 0 ; i < length ; i ++ ) { arr [ i ] = i ; } return arr ; }