github.com/primecitizens/pcz/std@v0.2.1/plat/js/webext/enterprise/platformkeys/bindings/ffi_bindings.ts (about) 1 import { importModule, Application, heap, Pointer } from "@ffi"; 2 3 importModule("plat/js/webext/enterprise/platformkeys", (A: Application) => { 4 const WEBEXT = typeof globalThis.browser === "undefined" ? globalThis.chrome : globalThis.browser; 5 6 return { 7 "constof_Algorithm": (ref: heap.Ref<string>): number => { 8 const idx = ["RSA", "ECDSA"].indexOf(A.H.get(ref)); 9 return idx < 0 ? 0 : idx + 1; 10 }, 11 12 "store_RegisterKeyOptions": (ptr: Pointer, ref: heap.Ref<any>) => { 13 const x = A.H.get<any>(ref); 14 15 if (typeof x === "undefined") { 16 A.store.Bool(ptr + 4, false); 17 A.store.Enum(ptr + 0, -1); 18 } else { 19 A.store.Bool(ptr + 4, true); 20 A.store.Enum(ptr + 0, ["RSA", "ECDSA"].indexOf(x["algorithm"] as string)); 21 } 22 }, 23 "load_RegisterKeyOptions": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 24 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 25 26 x["algorithm"] = A.load.Enum(ptr + 0, ["RSA", "ECDSA"]); 27 return create === A.H.TRUE ? A.H.push(x) : ref; 28 }, 29 "constof_Scope": (ref: heap.Ref<string>): number => { 30 const idx = ["USER", "MACHINE"].indexOf(A.H.get(ref)); 31 return idx < 0 ? 0 : idx + 1; 32 }, 33 34 "store_ChallengeKeyOptions": (ptr: Pointer, ref: heap.Ref<any>) => { 35 const x = A.H.get<any>(ref); 36 37 if (typeof x === "undefined") { 38 A.store.Bool(ptr + 16, false); 39 A.store.Ref(ptr + 0, undefined); 40 41 A.store.Bool(ptr + 4 + 4, false); 42 A.store.Enum(ptr + 4 + 0, -1); 43 A.store.Enum(ptr + 12, -1); 44 } else { 45 A.store.Bool(ptr + 16, true); 46 A.store.Ref(ptr + 0, x["challenge"]); 47 48 if (typeof x["registerKey"] === "undefined") { 49 A.store.Bool(ptr + 4 + 4, false); 50 A.store.Enum(ptr + 4 + 0, -1); 51 } else { 52 A.store.Bool(ptr + 4 + 4, true); 53 A.store.Enum(ptr + 4 + 0, ["RSA", "ECDSA"].indexOf(x["registerKey"]["algorithm"] as string)); 54 } 55 A.store.Enum(ptr + 12, ["USER", "MACHINE"].indexOf(x["scope"] as string)); 56 } 57 }, 58 "load_ChallengeKeyOptions": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 59 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 60 61 x["challenge"] = A.load.Ref(ptr + 0, undefined); 62 if (A.load.Bool(ptr + 4 + 4)) { 63 x["registerKey"] = {}; 64 x["registerKey"]["algorithm"] = A.load.Enum(ptr + 4 + 0, ["RSA", "ECDSA"]); 65 } else { 66 delete x["registerKey"]; 67 } 68 x["scope"] = A.load.Enum(ptr + 12, ["USER", "MACHINE"]); 69 return create === A.H.TRUE ? A.H.push(x) : ref; 70 }, 71 72 "store_Token": (ptr: Pointer, ref: heap.Ref<any>) => { 73 const x = A.H.get<any>(ref); 74 75 if (typeof x === "undefined") { 76 A.store.Bool(ptr + 12, false); 77 A.store.Ref(ptr + 0, undefined); 78 A.store.Ref(ptr + 4, undefined); 79 A.store.Ref(ptr + 8, undefined); 80 } else { 81 A.store.Bool(ptr + 12, true); 82 A.store.Ref(ptr + 0, x["id"]); 83 A.store.Ref(ptr + 4, x["subtleCrypto"]); 84 A.store.Ref(ptr + 8, x["softwareBackedSubtleCrypto"]); 85 } 86 }, 87 "load_Token": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 88 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 89 90 x["id"] = A.load.Ref(ptr + 0, undefined); 91 x["subtleCrypto"] = A.load.Ref(ptr + 4, undefined); 92 x["softwareBackedSubtleCrypto"] = A.load.Ref(ptr + 8, undefined); 93 return create === A.H.TRUE ? A.H.push(x) : ref; 94 }, 95 "has_ChallengeKey": (): heap.Ref<boolean> => { 96 if (WEBEXT?.enterprise?.platformKeys && "challengeKey" in WEBEXT?.enterprise?.platformKeys) { 97 return A.H.TRUE; 98 } 99 return A.H.FALSE; 100 }, 101 "func_ChallengeKey": (fn: Pointer): void => { 102 A.store.Ref(fn, WEBEXT.enterprise.platformKeys.challengeKey); 103 }, 104 "call_ChallengeKey": (retPtr: Pointer, options: Pointer, callback: heap.Ref<object>): void => { 105 const options_ffi = {}; 106 107 options_ffi["challenge"] = A.load.Ref(options + 0, undefined); 108 if (A.load.Bool(options + 4 + 4)) { 109 options_ffi["registerKey"] = {}; 110 options_ffi["registerKey"]["algorithm"] = A.load.Enum(options + 4 + 0, ["RSA", "ECDSA"]); 111 } 112 options_ffi["scope"] = A.load.Enum(options + 12, ["USER", "MACHINE"]); 113 114 const _ret = WEBEXT.enterprise.platformKeys.challengeKey(options_ffi, A.H.get<object>(callback)); 115 }, 116 "try_ChallengeKey": ( 117 retPtr: Pointer, 118 errPtr: Pointer, 119 options: Pointer, 120 callback: heap.Ref<object> 121 ): heap.Ref<boolean> => { 122 try { 123 const options_ffi = {}; 124 125 options_ffi["challenge"] = A.load.Ref(options + 0, undefined); 126 if (A.load.Bool(options + 4 + 4)) { 127 options_ffi["registerKey"] = {}; 128 options_ffi["registerKey"]["algorithm"] = A.load.Enum(options + 4 + 0, ["RSA", "ECDSA"]); 129 } 130 options_ffi["scope"] = A.load.Enum(options + 12, ["USER", "MACHINE"]); 131 132 const _ret = WEBEXT.enterprise.platformKeys.challengeKey(options_ffi, A.H.get<object>(callback)); 133 return A.H.TRUE; 134 } catch (err: any) { 135 A.store.Ref(errPtr, err); 136 return A.H.FALSE; 137 } 138 }, 139 "has_ChallengeMachineKey": (): heap.Ref<boolean> => { 140 if (WEBEXT?.enterprise?.platformKeys && "challengeMachineKey" in WEBEXT?.enterprise?.platformKeys) { 141 return A.H.TRUE; 142 } 143 return A.H.FALSE; 144 }, 145 "func_ChallengeMachineKey": (fn: Pointer): void => { 146 A.store.Ref(fn, WEBEXT.enterprise.platformKeys.challengeMachineKey); 147 }, 148 "call_ChallengeMachineKey": ( 149 retPtr: Pointer, 150 challenge: heap.Ref<object>, 151 registerKey: heap.Ref<boolean>, 152 callback: heap.Ref<object> 153 ): void => { 154 const _ret = WEBEXT.enterprise.platformKeys.challengeMachineKey( 155 A.H.get<object>(challenge), 156 registerKey === A.H.TRUE, 157 A.H.get<object>(callback) 158 ); 159 }, 160 "try_ChallengeMachineKey": ( 161 retPtr: Pointer, 162 errPtr: Pointer, 163 challenge: heap.Ref<object>, 164 registerKey: heap.Ref<boolean>, 165 callback: heap.Ref<object> 166 ): heap.Ref<boolean> => { 167 try { 168 const _ret = WEBEXT.enterprise.platformKeys.challengeMachineKey( 169 A.H.get<object>(challenge), 170 registerKey === A.H.TRUE, 171 A.H.get<object>(callback) 172 ); 173 return A.H.TRUE; 174 } catch (err: any) { 175 A.store.Ref(errPtr, err); 176 return A.H.FALSE; 177 } 178 }, 179 "has_ChallengeUserKey": (): heap.Ref<boolean> => { 180 if (WEBEXT?.enterprise?.platformKeys && "challengeUserKey" in WEBEXT?.enterprise?.platformKeys) { 181 return A.H.TRUE; 182 } 183 return A.H.FALSE; 184 }, 185 "func_ChallengeUserKey": (fn: Pointer): void => { 186 A.store.Ref(fn, WEBEXT.enterprise.platformKeys.challengeUserKey); 187 }, 188 "call_ChallengeUserKey": ( 189 retPtr: Pointer, 190 challenge: heap.Ref<object>, 191 registerKey: heap.Ref<boolean>, 192 callback: heap.Ref<object> 193 ): void => { 194 const _ret = WEBEXT.enterprise.platformKeys.challengeUserKey( 195 A.H.get<object>(challenge), 196 registerKey === A.H.TRUE, 197 A.H.get<object>(callback) 198 ); 199 }, 200 "try_ChallengeUserKey": ( 201 retPtr: Pointer, 202 errPtr: Pointer, 203 challenge: heap.Ref<object>, 204 registerKey: heap.Ref<boolean>, 205 callback: heap.Ref<object> 206 ): heap.Ref<boolean> => { 207 try { 208 const _ret = WEBEXT.enterprise.platformKeys.challengeUserKey( 209 A.H.get<object>(challenge), 210 registerKey === A.H.TRUE, 211 A.H.get<object>(callback) 212 ); 213 return A.H.TRUE; 214 } catch (err: any) { 215 A.store.Ref(errPtr, err); 216 return A.H.FALSE; 217 } 218 }, 219 "has_GetCertificates": (): heap.Ref<boolean> => { 220 if (WEBEXT?.enterprise?.platformKeys && "getCertificates" in WEBEXT?.enterprise?.platformKeys) { 221 return A.H.TRUE; 222 } 223 return A.H.FALSE; 224 }, 225 "func_GetCertificates": (fn: Pointer): void => { 226 A.store.Ref(fn, WEBEXT.enterprise.platformKeys.getCertificates); 227 }, 228 "call_GetCertificates": (retPtr: Pointer, tokenId: heap.Ref<object>, callback: heap.Ref<object>): void => { 229 const _ret = WEBEXT.enterprise.platformKeys.getCertificates(A.H.get<object>(tokenId), A.H.get<object>(callback)); 230 }, 231 "try_GetCertificates": ( 232 retPtr: Pointer, 233 errPtr: Pointer, 234 tokenId: heap.Ref<object>, 235 callback: heap.Ref<object> 236 ): heap.Ref<boolean> => { 237 try { 238 const _ret = WEBEXT.enterprise.platformKeys.getCertificates( 239 A.H.get<object>(tokenId), 240 A.H.get<object>(callback) 241 ); 242 return A.H.TRUE; 243 } catch (err: any) { 244 A.store.Ref(errPtr, err); 245 return A.H.FALSE; 246 } 247 }, 248 "has_GetTokens": (): heap.Ref<boolean> => { 249 if (WEBEXT?.enterprise?.platformKeys && "getTokens" in WEBEXT?.enterprise?.platformKeys) { 250 return A.H.TRUE; 251 } 252 return A.H.FALSE; 253 }, 254 "func_GetTokens": (fn: Pointer): void => { 255 A.store.Ref(fn, WEBEXT.enterprise.platformKeys.getTokens); 256 }, 257 "call_GetTokens": (retPtr: Pointer, callback: heap.Ref<object>): void => { 258 const _ret = WEBEXT.enterprise.platformKeys.getTokens(A.H.get<object>(callback)); 259 }, 260 "try_GetTokens": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 261 try { 262 const _ret = WEBEXT.enterprise.platformKeys.getTokens(A.H.get<object>(callback)); 263 return A.H.TRUE; 264 } catch (err: any) { 265 A.store.Ref(errPtr, err); 266 return A.H.FALSE; 267 } 268 }, 269 "has_ImportCertificate": (): heap.Ref<boolean> => { 270 if (WEBEXT?.enterprise?.platformKeys && "importCertificate" in WEBEXT?.enterprise?.platformKeys) { 271 return A.H.TRUE; 272 } 273 return A.H.FALSE; 274 }, 275 "func_ImportCertificate": (fn: Pointer): void => { 276 A.store.Ref(fn, WEBEXT.enterprise.platformKeys.importCertificate); 277 }, 278 "call_ImportCertificate": ( 279 retPtr: Pointer, 280 tokenId: heap.Ref<object>, 281 certificate: heap.Ref<object>, 282 callback: heap.Ref<object> 283 ): void => { 284 const _ret = WEBEXT.enterprise.platformKeys.importCertificate( 285 A.H.get<object>(tokenId), 286 A.H.get<object>(certificate), 287 A.H.get<object>(callback) 288 ); 289 }, 290 "try_ImportCertificate": ( 291 retPtr: Pointer, 292 errPtr: Pointer, 293 tokenId: heap.Ref<object>, 294 certificate: heap.Ref<object>, 295 callback: heap.Ref<object> 296 ): heap.Ref<boolean> => { 297 try { 298 const _ret = WEBEXT.enterprise.platformKeys.importCertificate( 299 A.H.get<object>(tokenId), 300 A.H.get<object>(certificate), 301 A.H.get<object>(callback) 302 ); 303 return A.H.TRUE; 304 } catch (err: any) { 305 A.store.Ref(errPtr, err); 306 return A.H.FALSE; 307 } 308 }, 309 "has_RemoveCertificate": (): heap.Ref<boolean> => { 310 if (WEBEXT?.enterprise?.platformKeys && "removeCertificate" in WEBEXT?.enterprise?.platformKeys) { 311 return A.H.TRUE; 312 } 313 return A.H.FALSE; 314 }, 315 "func_RemoveCertificate": (fn: Pointer): void => { 316 A.store.Ref(fn, WEBEXT.enterprise.platformKeys.removeCertificate); 317 }, 318 "call_RemoveCertificate": ( 319 retPtr: Pointer, 320 tokenId: heap.Ref<object>, 321 certificate: heap.Ref<object>, 322 callback: heap.Ref<object> 323 ): void => { 324 const _ret = WEBEXT.enterprise.platformKeys.removeCertificate( 325 A.H.get<object>(tokenId), 326 A.H.get<object>(certificate), 327 A.H.get<object>(callback) 328 ); 329 }, 330 "try_RemoveCertificate": ( 331 retPtr: Pointer, 332 errPtr: Pointer, 333 tokenId: heap.Ref<object>, 334 certificate: heap.Ref<object>, 335 callback: heap.Ref<object> 336 ): heap.Ref<boolean> => { 337 try { 338 const _ret = WEBEXT.enterprise.platformKeys.removeCertificate( 339 A.H.get<object>(tokenId), 340 A.H.get<object>(certificate), 341 A.H.get<object>(callback) 342 ); 343 return A.H.TRUE; 344 } catch (err: any) { 345 A.store.Ref(errPtr, err); 346 return A.H.FALSE; 347 } 348 }, 349 }; 350 });