Initial import from local backup (Documents-Playground/pakerpale)

node_modules/google-auth-library/build/src/crypto/browser/crypto.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Copyright 2019 Google LLC. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { Crypto, JwkCertificate } from '../crypto';
+export declare class BrowserCrypto implements Crypto {
+    constructor();
+    sha256DigestBase64(str: string): Promise<string>;
+    randomBytesBase64(count: number): string;
+    private static padBase64;
+    verify(pubkey: JwkCertificate, data: string, signature: string): Promise<boolean>;
+    sign(privateKey: JwkCertificate, data: string): Promise<string>;
+    decodeBase64StringUtf8(base64: string): string;
+    encodeBase64StringUtf8(text: string): string;
+}

node_modules/google-auth-library/build/src/crypto/browser/crypto.js

@@ -0,0 +1,94 @@
+"use strict";
+/**
+ * Copyright 2019 Google LLC. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+// This file implements crypto functions we need using in-browser
+// SubtleCrypto interface `window.crypto.subtle`.
+const base64js = require("base64-js");
+// Not all browsers support `TextEncoder`. The following `require` will
+// provide a fast UTF8-only replacement for those browsers that don't support
+// text encoding natively.
+if (typeof process === 'undefined' && typeof TextEncoder === 'undefined') {
+    require('fast-text-encoding');
+}
+class BrowserCrypto {
+    constructor() {
+        if (typeof window === 'undefined' ||
+            window.crypto === undefined ||
+            window.crypto.subtle === undefined) {
+            throw new Error("SubtleCrypto not found. Make sure it's an https:// website.");
+        }
+    }
+    async sha256DigestBase64(str) {
+        // SubtleCrypto digest() method is async, so we must make
+        // this method async as well.
+        // To calculate SHA256 digest using SubtleCrypto, we first
+        // need to convert an input string to an ArrayBuffer:
+        const inputBuffer = new TextEncoder().encode(str);
+        // Result is ArrayBuffer as well.
+        const outputBuffer = await window.crypto.subtle.digest('SHA-256', inputBuffer);
+        return base64js.fromByteArray(new Uint8Array(outputBuffer));
+    }
+    randomBytesBase64(count) {
+        const array = new Uint8Array(count);
+        window.crypto.getRandomValues(array);
+        return base64js.fromByteArray(array);
+    }
+    static padBase64(base64) {
+        // base64js requires padding, so let's add some '='
+        while (base64.length % 4 !== 0) {
+            base64 += '=';
+        }
+        return base64;
+    }
+    async verify(pubkey, data, signature) {
+        const algo = {
+            name: 'RSASSA-PKCS1-v1_5',
+            hash: { name: 'SHA-256' },
+        };
+        const dataArray = new TextEncoder().encode(data);
+        const signatureArray = base64js.toByteArray(BrowserCrypto.padBase64(signature));
+        const cryptoKey = await window.crypto.subtle.importKey('jwk', pubkey, algo, true, ['verify']);
+        // SubtleCrypto's verify method is async so we must make
+        // this method async as well.
+        const result = await window.crypto.subtle.verify(algo, cryptoKey, signatureArray, dataArray);
+        return result;
+    }
+    async sign(privateKey, data) {
+        const algo = {
+            name: 'RSASSA-PKCS1-v1_5',
+            hash: { name: 'SHA-256' },
+        };
+        const dataArray = new TextEncoder().encode(data);
+        const cryptoKey = await window.crypto.subtle.importKey('jwk', privateKey, algo, true, ['sign']);
+        // SubtleCrypto's sign method is async so we must make
+        // this method async as well.
+        const result = await window.crypto.subtle.sign(algo, cryptoKey, dataArray);
+        return base64js.fromByteArray(new Uint8Array(result));
+    }
+    decodeBase64StringUtf8(base64) {
+        const uint8array = base64js.toByteArray(BrowserCrypto.padBase64(base64));
+        const result = new TextDecoder().decode(uint8array);
+        return result;
+    }
+    encodeBase64StringUtf8(text) {
+        const uint8array = new TextEncoder().encode(text);
+        const result = base64js.fromByteArray(uint8array);
+        return result;
+    }
+}
+exports.BrowserCrypto = BrowserCrypto;
+//# sourceMappingURL=crypto.js.map

node_modules/google-auth-library/build/src/crypto/crypto.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Copyright 2019 Google LLC. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/// <reference types="node" />
+export interface JwkCertificate {
+    kty: string;
+    alg: string;
+    use?: string;
+    kid: string;
+    n: string;
+    e: string;
+}
+export interface CryptoSigner {
+    update(data: string): void;
+    sign(key: string, outputFormat: string): string;
+}
+export interface Crypto {
+    sha256DigestBase64(str: string): Promise<string>;
+    randomBytesBase64(n: number): string;
+    verify(pubkey: string | JwkCertificate, data: string | Buffer, signature: string): Promise<boolean>;
+    sign(privateKey: string | JwkCertificate, data: string | Buffer): Promise<string>;
+    decodeBase64StringUtf8(base64: string): string;
+    encodeBase64StringUtf8(text: string): string;
+}
+export declare function createCrypto(): Crypto;
+export declare function hasBrowserCrypto(): boolean;

node_modules/google-auth-library/build/src/crypto/crypto.js

@@ -0,0 +1,33 @@
+"use strict";
+/**
+ * Copyright 2019 Google LLC. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const crypto_1 = require("./browser/crypto");
+const crypto_2 = require("./node/crypto");
+function createCrypto() {
+    if (hasBrowserCrypto()) {
+        return new crypto_1.BrowserCrypto();
+    }
+    return new crypto_2.NodeCrypto();
+}
+exports.createCrypto = createCrypto;
+function hasBrowserCrypto() {
+    return (typeof window !== 'undefined' &&
+        typeof window.crypto !== 'undefined' &&
+        typeof window.crypto.subtle !== 'undefined');
+}
+exports.hasBrowserCrypto = hasBrowserCrypto;
+//# sourceMappingURL=crypto.js.map

node_modules/google-auth-library/build/src/crypto/node/crypto.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Copyright 2019 Google LLC. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/// <reference types="node" />
+import { Crypto } from '../crypto';
+export declare class NodeCrypto implements Crypto {
+    sha256DigestBase64(str: string): Promise<string>;
+    randomBytesBase64(count: number): string;
+    verify(pubkey: string, data: string | Buffer, signature: string): Promise<boolean>;
+    sign(privateKey: string, data: string | Buffer): Promise<string>;
+    decodeBase64StringUtf8(base64: string): string;
+    encodeBase64StringUtf8(text: string): string;
+}

node_modules/google-auth-library/build/src/crypto/node/crypto.js

@@ -0,0 +1,49 @@
+"use strict";
+/**
+ * Copyright 2019 Google LLC. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const crypto = require("crypto");
+class NodeCrypto {
+    async sha256DigestBase64(str) {
+        return crypto
+            .createHash('sha256')
+            .update(str)
+            .digest('base64');
+    }
+    randomBytesBase64(count) {
+        return crypto.randomBytes(count).toString('base64');
+    }
+    async verify(pubkey, data, signature) {
+        const verifier = crypto.createVerify('sha256');
+        verifier.update(data);
+        verifier.end();
+        return verifier.verify(pubkey, signature, 'base64');
+    }
+    async sign(privateKey, data) {
+        const signer = crypto.createSign('RSA-SHA256');
+        signer.update(data);
+        signer.end();
+        return signer.sign(privateKey, 'base64');
+    }
+    decodeBase64StringUtf8(base64) {
+        return Buffer.from(base64, 'base64').toString('utf-8');
+    }
+    encodeBase64StringUtf8(text) {
+        return Buffer.from(text, 'utf-8').toString('base64');
+    }
+}
+exports.NodeCrypto = NodeCrypto;
+//# sourceMappingURL=crypto.js.map