'f'

mh-two-thousand-and-two

2024-04-12 26f2711ef9461961fb953e2b497bd314ef95e345

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
/*
    MIT License http://www.opensource.org/licenses/mit-license.php
    Author Tobias Koppers @sokra
*/
"use strict";
 
const AbstractMethodError = require("../AbstractMethodError");
 
const BULK_SIZE = 1000;
 
class Hash {
    /**
     * Update hash {@link https://nodejs.org/api/crypto.html#crypto_hash_update_data_inputencoding}
     * @param {string|Buffer} data data
     * @param {string=} inputEncoding data encoding
     * @returns {this} updated hash
     */
    update(data, inputEncoding) {
        throw new AbstractMethodError();
    }
 
    /**
     * Calculates the digest {@link https://nodejs.org/api/crypto.html#crypto_hash_digest_encoding}
     * @param {string=} encoding encoding of the return value
     * @returns {string|Buffer} digest
     */
    digest(encoding) {
        throw new AbstractMethodError();
    }
}
 
class BulkUpdateDecorator extends Hash {
    /**
     * @param {Hash} hash hash
     */
    constructor(hash) {
        super();
        this.hash = hash;
        this.buffer = "";
    }
 
    /**
     * Update hash {@link https://nodejs.org/api/crypto.html#crypto_hash_update_data_inputencoding}
     * @param {string|Buffer} data data
     * @param {string=} inputEncoding data encoding
     * @returns {this} updated hash
     */
    update(data, inputEncoding) {
        if (
            inputEncoding !== undefined ||
            typeof data !== "string" ||
            data.length > BULK_SIZE
        ) {
            if (this.buffer.length > 0) {
                this.hash.update(this.buffer);
                this.buffer = "";
            }
            this.hash.update(data, inputEncoding);
        } else {
            this.buffer += data;
            if (this.buffer.length > BULK_SIZE) {
                this.hash.update(this.buffer);
                this.buffer = "";
            }
        }
        return this;
    }
 
    /**
     * Calculates the digest {@link https://nodejs.org/api/crypto.html#crypto_hash_digest_encoding}
     * @param {string=} encoding encoding of the return value
     * @returns {string|Buffer} digest
     */
    digest(encoding) {
        if (this.buffer.length > 0) {
            this.hash.update(this.buffer);
        }
        var digestResult = this.hash.digest(encoding);
        return typeof digestResult === "string"
            ? digestResult
            : digestResult.toString();
    }
}
 
/**
 * istanbul ignore next
 */
class DebugHash extends Hash {
    constructor() {
        super();
        this.string = "";
    }
 
    /**
     * Update hash {@link https://nodejs.org/api/crypto.html#crypto_hash_update_data_inputencoding}
     * @param {string|Buffer} data data
     * @param {string=} inputEncoding data encoding
     * @returns {this} updated hash
     */
    update(data, inputEncoding) {
        if (typeof data !== "string") data = data.toString("utf-8");
        this.string += data;
        return this;
    }
 
    /**
     * Calculates the digest {@link https://nodejs.org/api/crypto.html#crypto_hash_digest_encoding}
     * @param {string=} encoding encoding of the return value
     * @returns {string|Buffer} digest
     */
    digest(encoding) {
        return this.string.replace(/[^a-z0-9]+/gi, m =>
            Buffer.from(m).toString("hex")
        );
    }
}
 
/** @type {typeof import("crypto") | undefined} */
let crypto = undefined;
/** @type {typeof import("./hash/md4") | undefined} */
let createMd4 = undefined;
/** @type {typeof import("./hash/BatchedHash") | undefined} */
let BatchedHash = undefined;
 
/** @type {number} */
const NODE_MAJOR_VERSION = parseInt(process.versions.node, 10);
 
/**
 * Creates a hash by name or function
 * @param {string | HashConstructor} algorithm the algorithm name or a constructor creating a hash
 * @returns {Hash} the hash
 */
module.exports = algorithm => {
    if (typeof algorithm === "function") {
        return new BulkUpdateDecorator(new algorithm());
    }
 
    switch (algorithm) {
        // TODO add non-cryptographic algorithm here
        case "debug":
            return new DebugHash();
        case "md4":
            if (NODE_MAJOR_VERSION >= 18) {
                if (createMd4 === undefined) {
                    createMd4 = require("./hash/md4");
                    if (BatchedHash === undefined) {
                        BatchedHash = require("./hash/BatchedHash");
                    }
                }
                return new /** @type {typeof import("./hash/BatchedHash")} */ (BatchedHash)(
                    createMd4()
                );
            }
        // If we are on Node.js < 18, fall through to the default case
        // eslint-disable-next-line no-fallthrough
 
        case "native-md4":
            if (NODE_MAJOR_VERSION >= 18) {
                if (crypto === undefined) crypto = require("crypto");
                return new BulkUpdateDecorator(
                    /** @type {typeof import("crypto")} */ (crypto).createHash("md4")
                );
            }
        // If we are on Node.js < 18, fall through to the default case
        // eslint-disable-next-line no-fallthrough
 
        default:
            if (crypto === undefined) crypto = require("crypto");
            return new BulkUpdateDecorator(crypto.createHash(algorithm));
    }
};
 
module.exports.Hash = Hash;
/** @typedef {typeof Hash} HashConstructor */