@depup/aws-sdk__checksums 3.1000.18-depup.0

package/dist-cjs/submodules/sha/index.js

@@ -0,0 +1,312 @@
+const { toUint8Array, concatBytes } = require("@smithy/core/serde");
+const { createHmac, createHash } = require("node:crypto");
+const { Sha256, Sha256Js, Sha256Node } = require("@smithy/core/checksum");
+exports.Sha256 = Sha256;
+exports.Sha256Js = Sha256Js;
+exports.Sha256Node = Sha256Node;
+
+const BLOCK = 64;
+const DIGEST_LENGTH = 20;
+const INIT = new Int32Array([0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0]);
+const K = new Int32Array([0x5a827999, 0x6ed9eba1, 0x8f1bbcdc, 0xca62c1d6]);
+class Sha1Js {
+    digestLength = DIGEST_LENGTH;
+    state = Int32Array.from(INIT);
+    w;
+    buffer = new Uint8Array(BLOCK);
+    bufferLength = 0;
+    bytesHashed = 0;
+    finished = false;
+    inner;
+    outer;
+    constructor(secret) {
+        if (secret) {
+            const key = Sha1Js.normalizeKey(secret);
+            this.inner = new Sha1Js();
+            this.outer = new Sha1Js();
+            const pad = new Uint8Array(BLOCK * 2);
+            for (let i = 0; i < BLOCK; ++i) {
+                pad[i] = 0x36 ^ key[i];
+                pad[i + BLOCK] = 0x5c ^ key[i];
+            }
+            this.inner.update(pad.subarray(0, BLOCK));
+            this.outer.update(pad.subarray(BLOCK));
+        }
+    }
+    update(data) {
+        if (this.finished) {
+            throw new Error("Attempted to update an already finished HMAC.");
+        }
+        if (this.inner) {
+            this.inner.update(data);
+            return;
+        }
+        let pos = 0;
+        let { length } = data;
+        this.bytesHashed += length;
+        if (this.bufferLength > 0) {
+            while (length > 0 && this.bufferLength < BLOCK) {
+                this.buffer[this.bufferLength++] = data[pos++];
+                --length;
+            }
+            if (this.bufferLength === BLOCK) {
+                this.hashBuffer(this.buffer, 0);
+                this.bufferLength = 0;
+            }
+        }
+        while (length >= BLOCK) {
+            this.hashBuffer(data, pos);
+            pos += BLOCK;
+            length -= BLOCK;
+        }
+        while (length > 0) {
+            this.buffer[this.bufferLength++] = data[pos++];
+            --length;
+        }
+    }
+    async digest() {
+        if (this.inner && this.outer) {
+            if (this.finished) {
+                throw new Error("Attempted to digest an already finished HMAC.");
+            }
+            this.finished = true;
+            const innerDigest = this.inner.digestSync();
+            this.outer.update(innerDigest);
+            return this.outer.digestSync();
+        }
+        return this.digestSync();
+    }
+    reset() {
+        this.state = Int32Array.from(INIT);
+        this.buffer = new Uint8Array(BLOCK);
+        this.bufferLength = 0;
+        this.bytesHashed = 0;
+    }
+    digestSync() {
+        const state = this.state.slice();
+        const buffer = this.buffer.slice();
+        let bufferLength = this.bufferLength;
+        const bitsHi = (this.bytesHashed / 0x20000000) | 0;
+        const bitsLo = this.bytesHashed << 3;
+        buffer[bufferLength++] = 0x80;
+        if (bufferLength > BLOCK - 8) {
+            for (let i = bufferLength; i < BLOCK; ++i) {
+                buffer[i] = 0;
+            }
+            this.hashBufferWith(state, buffer, 0);
+            bufferLength = 0;
+        }
+        for (let i = bufferLength; i < BLOCK - 8; ++i) {
+            buffer[i] = 0;
+        }
+        const v = new DataView(buffer.buffer, buffer.byteOffset, BLOCK);
+        v.setUint32(BLOCK - 8, bitsHi, false);
+        v.setUint32(BLOCK - 4, bitsLo, false);
+        this.hashBufferWith(state, buffer, 0);
+        const out = new Uint8Array(DIGEST_LENGTH);
+        out[0] = (state[0] >>> 24) & 0xff;
+        out[1] = (state[0] >>> 16) & 0xff;
+        out[2] = (state[0] >>> 8) & 0xff;
+        out[3] = state[0] & 0xff;
+        out[4] = (state[1] >>> 24) & 0xff;
+        out[5] = (state[1] >>> 16) & 0xff;
+        out[6] = (state[1] >>> 8) & 0xff;
+        out[7] = state[1] & 0xff;
+        out[8] = (state[2] >>> 24) & 0xff;
+        out[9] = (state[2] >>> 16) & 0xff;
+        out[10] = (state[2] >>> 8) & 0xff;
+        out[11] = state[2] & 0xff;
+        out[12] = (state[3] >>> 24) & 0xff;
+        out[13] = (state[3] >>> 16) & 0xff;
+        out[14] = (state[3] >>> 8) & 0xff;
+        out[15] = state[3] & 0xff;
+        out[16] = (state[4] >>> 24) & 0xff;
+        out[17] = (state[4] >>> 16) & 0xff;
+        out[18] = (state[4] >>> 8) & 0xff;
+        out[19] = state[4] & 0xff;
+        return out;
+    }
+    static normalizeKey(secret) {
+        const key = toUint8Array(secret);
+        if (key.byteLength > BLOCK) {
+            const h = new Sha1Js();
+            h.update(key);
+            const digest = h.digestSync();
+            const padded = new Uint8Array(BLOCK);
+            padded.set(digest);
+            return padded;
+        }
+        const padded = new Uint8Array(BLOCK);
+        padded.set(key);
+        return padded;
+    }
+    hashBuffer(data, offset) {
+        this.hashBufferWith(this.state, data, offset);
+    }
+    hashBufferWith(state, data, offset) {
+        const w = (this.w ??= new Int32Array(80));
+        let s0 = state[0], s1 = state[1], s2 = state[2], s3 = state[3], s4 = state[4];
+        for (let t = 0; t < 16; ++t) {
+            w[t] =
+                ((data[offset + t * 4] & 0xff) << 24) |
+                    ((data[offset + t * 4 + 1] & 0xff) << 16) |
+                    ((data[offset + t * 4 + 2] & 0xff) << 8) |
+                    (data[offset + t * 4 + 3] & 0xff);
+        }
+        for (let t = 16; t < 80; ++t) {
+            const x = w[t - 3] ^ w[t - 8] ^ w[t - 14] ^ w[t - 16];
+            w[t] = (x << 1) | (x >>> 31);
+        }
+        for (let t = 0; t < 80; ++t) {
+            const r = t < 20 ? 0 : t < 40 ? 1 : t < 60 ? 2 : 3;
+            const temp = (((((s0 << 5) | (s0 >>> 27)) +
+                (r === 0 ? (s1 & s2) ^ (~s1 & s3) : r === 2 ? (s1 & s2) ^ (s1 & s3) ^ (s2 & s3) : s1 ^ s2 ^ s3)) |
+                0) +
+                ((s4 + ((K[r] + w[t]) | 0)) | 0)) |
+                0;
+            s4 = s3;
+            s3 = s2;
+            s2 = (s1 << 30) | (s1 >>> 2);
+            s1 = s0;
+            s0 = temp;
+        }
+        state[0] = (state[0] + s0) | 0;
+        state[1] = (state[1] + s1) | 0;
+        state[2] = (state[2] + s2) | 0;
+        state[3] = (state[3] + s3) | 0;
+        state[4] = (state[4] + s4) | 0;
+    }
+}
+
+const hasNativeCrypto = (() => {
+    try {
+        createHash("sha1");
+        return true;
+    }
+    catch {
+        return false;
+    }
+})();
+const Sha1Node = hasNativeCrypto ? buildNativeClass() : Sha1Js;
+function buildNativeClass() {
+    return class Sha1Node {
+        digestLength = 20;
+        secret;
+        hash;
+        isHmac;
+        finished = false;
+        constructor(secret) {
+            this.secret = secret;
+            this.isHmac = !!secret;
+            this.hash = this.createHash();
+        }
+        update(data) {
+            if (this.finished) {
+                throw new Error("Attempted to update an already finished hash.");
+            }
+            this.hash.update(data);
+        }
+        async digest() {
+            let buf;
+            if (this.isHmac) {
+                this.finished = true;
+                buf = this.hash.digest();
+            }
+            else {
+                buf = this.hash.copy().digest();
+            }
+            return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
+        }
+        reset() {
+            this.hash = this.createHash();
+            this.finished = false;
+        }
+        createHash() {
+            return this.secret ? createHmac("sha1", toBuffer(this.secret)) : createHash("sha1");
+        }
+    };
+}
+function toBuffer(data) {
+    if (typeof data === "string") {
+        return data;
+    }
+    if (ArrayBuffer.isView(data)) {
+        return Buffer.from(data.buffer, data.byteOffset, data.byteLength);
+    }
+    return Buffer.from(data);
+}
+
+const { digest, sign, importKey } = globalThis?.crypto?.subtle ?? {};
+const subtle = typeof digest === "function" && typeof sign === "function" && typeof importKey === "function"
+    ? globalThis.crypto.subtle
+    : undefined;
+const MAX_PENDING_BYTES = 8 * 1024 * 1024;
+class Sha1WebCrypto {
+    digestLength = 20;
+    secret;
+    pending = [];
+    pendingBytes = 0;
+    fallback;
+    finished = false;
+    constructor(secret) {
+        if (secret) {
+            this.secret = toUint8Array(secret);
+        }
+    }
+    update(data) {
+        if (this.finished) {
+            throw new Error("Attempted to update an already finished HMAC.");
+        }
+        if (this.fallback) {
+            this.fallback.update(data);
+            return;
+        }
+        this.pending.push(data.slice());
+        this.pendingBytes += data.byteLength;
+        if (this.pendingBytes >= MAX_PENDING_BYTES) {
+            this.switchToFallback();
+        }
+    }
+    async digest() {
+        if (this.fallback) {
+            return this.fallback.digest();
+        }
+        if (this.secret && this.finished) {
+            throw new Error("Attempted to digest an already finished HMAC.");
+        }
+        const data = concatBytes(this.pending);
+        if (subtle) {
+            if (this.secret) {
+                this.finished = true;
+                const key = await subtle.importKey("raw", this.secret, { name: "HMAC", hash: "SHA-1" }, false, ["sign"]);
+                const sig = await subtle.sign("HMAC", key, data);
+                return new Uint8Array(sig);
+            }
+            const hash = await subtle.digest("SHA-1", data);
+            return new Uint8Array(hash);
+        }
+        const sha1 = new Sha1Js(this.secret);
+        sha1.update(data);
+        return sha1.digest();
+    }
+    reset() {
+        this.pending = [];
+        this.pendingBytes = 0;
+        this.fallback = undefined;
+        this.finished = false;
+    }
+    switchToFallback() {
+        const sha1Js = new Sha1Js(this.secret);
+        for (const chunk of this.pending) {
+            sha1Js.update(chunk);
+        }
+        this.fallback = sha1Js;
+        this.pending = [];
+        this.pendingBytes = 0;
+    }
+}
+
+exports.Sha1 = Sha1Node;
+exports.Sha1Js = Sha1Js;
+exports.Sha1Node = Sha1Node;
+exports.Sha1WebCrypto = Sha1WebCrypto;

package/dist-es/index.js

@@ -0,0 +1,2 @@
+export { Crc64Nvme, Crc64NvmeJs, crc64NvmeCrtContainer } from "@aws-sdk/checksums/crc";
+export { ENV_REQUEST_CHECKSUM_CALCULATION, CONFIG_REQUEST_CHECKSUM_CALCULATION, NODE_REQUEST_CHECKSUM_CALCULATION_CONFIG_OPTIONS, ENV_RESPONSE_CHECKSUM_VALIDATION, CONFIG_RESPONSE_CHECKSUM_VALIDATION, NODE_RESPONSE_CHECKSUM_VALIDATION_CONFIG_OPTIONS, RequestChecksumCalculation, DEFAULT_REQUEST_CHECKSUM_CALCULATION, ResponseChecksumValidation, DEFAULT_RESPONSE_CHECKSUM_VALIDATION, ChecksumAlgorithm, ChecksumLocation, DEFAULT_CHECKSUM_ALGORITHM, flexibleChecksumsMiddlewareOptions, flexibleChecksumsMiddleware, getFlexibleChecksumsPlugin, resolveFlexibleChecksumsConfig, } from "@aws-sdk/checksums/flexible-checksums";

package/dist-es/submodules/crc/crc32c/Crc32cJs.js

@@ -0,0 +1,31 @@
+const T = new Uint32Array(256);
+for (let i = 0; i < 256; ++i) {
+    let c = i;
+    for (let j = 0; j < 8; ++j) {
+        c = c & 1 ? 0x82f63b78 ^ (c >>> 1) : c >>> 1;
+    }
+    T[i] = c >>> 0;
+}
+export class Crc32cJs {
+    digestLength = 4;
+    crc = 0xffff_ffff;
+    update(data) {
+        let crc = this.crc;
+        for (let i = 0; i < data.length; ++i) {
+            crc = (crc >>> 8) ^ T[(crc ^ data[i]) & 0xff];
+        }
+        this.crc = crc;
+    }
+    async digest() {
+        const value = (this.crc ^ 0xffff_ffff) >>> 0;
+        const out = new Uint8Array(4);
+        out[0] = value >>> 24;
+        out[1] = (value >>> 16) & 0xff;
+        out[2] = (value >>> 8) & 0xff;
+        out[3] = value & 0xff;
+        return out;
+    }
+    reset() {
+        this.crc = 0xffff_ffff;
+    }
+}

package/dist-es/submodules/crc/crc32c/Crc32cNode.js

@@ -0,0 +1,2 @@
+import { Crc32cJs } from "./Crc32cJs";
+export const Crc32cNode = Crc32cJs;

package/dist-es/submodules/crc/crc64-nvme/Crc64Nvme.js

@@ -0,0 +1,18 @@
+import { crc64NvmeCrtContainer } from "./crc64-nvme-crt-container";
+import { Crc64NvmeJs } from "./Crc64NvmeJs";
+export class Crc64Nvme {
+    impl;
+    constructor() {
+        const Crt = crc64NvmeCrtContainer.CrtCrc64Nvme;
+        this.impl = Crt ? new Crt() : new Crc64NvmeJs();
+    }
+    update(data) {
+        this.impl.update(data);
+    }
+    async digest() {
+        return this.impl.digest();
+    }
+    reset() {
+        this.impl.reset();
+    }
+}

package/dist-es/submodules/crc/crc64-nvme/Crc64NvmeJs.js

@@ -0,0 +1,92 @@
+const generateCRC64NVMETable = () => {
+    const sliceLength = 8;
+    const tables = new Array(sliceLength);
+    for (let slice = 0; slice < sliceLength; slice++) {
+        const table = new Array(512);
+        for (let i = 0; i < 256; i++) {
+            let crc = BigInt(i);
+            for (let j = 0; j < 8 * (slice + 1); j++) {
+                if (crc & 1n) {
+                    crc = (crc >> 1n) ^ 0x9a6c9329ac4bc9b5n;
+                }
+                else {
+                    crc = crc >> 1n;
+                }
+            }
+            table[i * 2] = Number((crc >> 32n) & 0xffffffffn);
+            table[i * 2 + 1] = Number(crc & 0xffffffffn);
+        }
+        tables[slice] = new Uint32Array(table);
+    }
+    return tables;
+};
+let CRC64_NVME_REVERSED_TABLE;
+let t0, t1, t2, t3;
+let t4, t5, t6, t7;
+const ensureTablesInitialized = () => {
+    if (!CRC64_NVME_REVERSED_TABLE) {
+        CRC64_NVME_REVERSED_TABLE = generateCRC64NVMETable();
+        [t0, t1, t2, t3, t4, t5, t6, t7] = CRC64_NVME_REVERSED_TABLE;
+    }
+};
+export class Crc64NvmeJs {
+    c1 = 0;
+    c2 = 0;
+    constructor() {
+        ensureTablesInitialized();
+        this.reset();
+    }
+    update(data) {
+        const len = data.length;
+        let i = 0;
+        let crc1 = this.c1;
+        let crc2 = this.c2;
+        while (i + 8 <= len) {
+            const idx0 = ((crc2 ^ data[i++]) & 255) << 1;
+            const idx1 = (((crc2 >>> 8) ^ data[i++]) & 255) << 1;
+            const idx2 = (((crc2 >>> 16) ^ data[i++]) & 255) << 1;
+            const idx3 = (((crc2 >>> 24) ^ data[i++]) & 255) << 1;
+            const idx4 = ((crc1 ^ data[i++]) & 255) << 1;
+            const idx5 = (((crc1 >>> 8) ^ data[i++]) & 255) << 1;
+            const idx6 = (((crc1 >>> 16) ^ data[i++]) & 255) << 1;
+            const idx7 = (((crc1 >>> 24) ^ data[i++]) & 255) << 1;
+            crc1 = t7[idx0] ^ t6[idx1] ^ t5[idx2] ^ t4[idx3] ^ t3[idx4] ^ t2[idx5] ^ t1[idx6] ^ t0[idx7];
+            crc2 =
+                t7[idx0 + 1] ^
+                    t6[idx1 + 1] ^
+                    t5[idx2 + 1] ^
+                    t4[idx3 + 1] ^
+                    t3[idx4 + 1] ^
+                    t2[idx5 + 1] ^
+                    t1[idx6 + 1] ^
+                    t0[idx7 + 1];
+        }
+        while (i < len) {
+            const idx = ((crc2 ^ data[i]) & 255) << 1;
+            crc2 = ((crc2 >>> 8) | ((crc1 & 255) << 24)) >>> 0;
+            crc1 = (crc1 >>> 8) ^ t0[idx];
+            crc2 ^= t0[idx + 1];
+            ++i;
+        }
+        this.c1 = crc1;
+        this.c2 = crc2;
+    }
+    async digest() {
+        const c1 = this.c1 ^ 4294967295;
+        const c2 = this.c2 ^ 4294967295;
+        return new Uint8Array([
+            c1 >>> 24,
+            (c1 >>> 16) & 255,
+            (c1 >>> 8) & 255,
+            c1 & 255,
+            c2 >>> 24,
+            (c2 >>> 16) & 255,
+            (c2 >>> 8) & 255,
+            c2 & 255,
+        ]);
+    }
+    reset() {
+        this.c1 = 4294967295;
+        this.c2 = 4294967295;
+    }
+}

package/dist-es/submodules/crc/crc64-nvme/crc64-nvme-crt-container.js

@@ -0,0 +1,3 @@
+export const crc64NvmeCrtContainer = {
+    CrtCrc64Nvme: null,
+};

package/dist-es/submodules/crc/index.browser.js

@@ -0,0 +1,6 @@
+const no = Symbol.for("node-only");
+export { Crc32cJs, Crc32cJs as Crc32c } from "./crc32c/Crc32cJs";
+export const Crc32cNode = no;
+export { Crc64NvmeJs, Crc64NvmeJs as Crc64Nvme } from "./crc64-nvme/Crc64NvmeJs";
+export { crc64NvmeCrtContainer } from "./crc64-nvme/crc64-nvme-crt-container";
+export { Crc32, Crc32Js, Crc32Node } from "@smithy/core/checksum";

package/dist-es/submodules/crc/index.js

@@ -0,0 +1,6 @@
+export { Crc32cJs } from "./crc32c/Crc32cJs";
+export { Crc32cNode, Crc32cNode as Crc32c } from "./crc32c/Crc32cNode";
+export { Crc64Nvme } from "./crc64-nvme/Crc64Nvme";
+export { Crc64NvmeJs } from "./crc64-nvme/Crc64NvmeJs";
+export { crc64NvmeCrtContainer } from "./crc64-nvme/crc64-nvme-crt-container";
+export { Crc32, Crc32Js, Crc32Node } from "@smithy/core/checksum";

package/dist-es/submodules/flexible-checksums/NODE_REQUEST_CHECKSUM_CALCULATION_CONFIG_OPTIONS.js

@@ -0,0 +1,9 @@
+import { DEFAULT_REQUEST_CHECKSUM_CALCULATION, RequestChecksumCalculation } from "./constants";
+import { SelectorType, stringUnionSelector } from "./stringUnionSelector";
+export const ENV_REQUEST_CHECKSUM_CALCULATION = "AWS_REQUEST_CHECKSUM_CALCULATION";
+export const CONFIG_REQUEST_CHECKSUM_CALCULATION = "request_checksum_calculation";
+export const NODE_REQUEST_CHECKSUM_CALCULATION_CONFIG_OPTIONS = {
+    environmentVariableSelector: (env) => stringUnionSelector(env, ENV_REQUEST_CHECKSUM_CALCULATION, RequestChecksumCalculation, SelectorType.ENV),
+    configFileSelector: (profile) => stringUnionSelector(profile, CONFIG_REQUEST_CHECKSUM_CALCULATION, RequestChecksumCalculation, SelectorType.CONFIG),
+    default: DEFAULT_REQUEST_CHECKSUM_CALCULATION,
+};

package/dist-es/submodules/flexible-checksums/NODE_RESPONSE_CHECKSUM_VALIDATION_CONFIG_OPTIONS.js

@@ -0,0 +1,9 @@
+import { DEFAULT_RESPONSE_CHECKSUM_VALIDATION, ResponseChecksumValidation } from "./constants";
+import { SelectorType, stringUnionSelector } from "./stringUnionSelector";
+export const ENV_RESPONSE_CHECKSUM_VALIDATION = "AWS_RESPONSE_CHECKSUM_VALIDATION";
+export const CONFIG_RESPONSE_CHECKSUM_VALIDATION = "response_checksum_validation";
+export const NODE_RESPONSE_CHECKSUM_VALIDATION_CONFIG_OPTIONS = {
+    environmentVariableSelector: (env) => stringUnionSelector(env, ENV_RESPONSE_CHECKSUM_VALIDATION, ResponseChecksumValidation, SelectorType.ENV),
+    configFileSelector: (profile) => stringUnionSelector(profile, CONFIG_RESPONSE_CHECKSUM_VALIDATION, ResponseChecksumValidation, SelectorType.CONFIG),
+    default: DEFAULT_RESPONSE_CHECKSUM_VALIDATION,
+};

package/dist-es/submodules/flexible-checksums/configuration.js

@@ -0,0 +1 @@
+export {};

package/dist-es/submodules/flexible-checksums/constants.js

@@ -0,0 +1,25 @@
+export const RequestChecksumCalculation = {
+    WHEN_SUPPORTED: "WHEN_SUPPORTED",
+    WHEN_REQUIRED: "WHEN_REQUIRED",
+};
+export const DEFAULT_REQUEST_CHECKSUM_CALCULATION = RequestChecksumCalculation.WHEN_SUPPORTED;
+export const ResponseChecksumValidation = {
+    WHEN_SUPPORTED: "WHEN_SUPPORTED",
+    WHEN_REQUIRED: "WHEN_REQUIRED",
+};
+export const DEFAULT_RESPONSE_CHECKSUM_VALIDATION = RequestChecksumCalculation.WHEN_SUPPORTED;
+export var ChecksumAlgorithm;
+(function (ChecksumAlgorithm) {
+    ChecksumAlgorithm["MD5"] = "MD5";
+    ChecksumAlgorithm["CRC32"] = "CRC32";
+    ChecksumAlgorithm["CRC32C"] = "CRC32C";
+    ChecksumAlgorithm["CRC64NVME"] = "CRC64NVME";
+    ChecksumAlgorithm["SHA1"] = "SHA1";
+    ChecksumAlgorithm["SHA256"] = "SHA256";
+})(ChecksumAlgorithm || (ChecksumAlgorithm = {}));
+export var ChecksumLocation;
+(function (ChecksumLocation) {
+    ChecksumLocation["HEADER"] = "header";
+    ChecksumLocation["TRAILER"] = "trailer";
+})(ChecksumLocation || (ChecksumLocation = {}));
+export const DEFAULT_CHECKSUM_ALGORITHM = ChecksumAlgorithm.CRC32;

package/dist-es/submodules/flexible-checksums/flexibleChecksumsInputMiddleware.js

@@ -0,0 +1,37 @@
+import { setFeature } from "@aws-sdk/core/client";
+import { RequestChecksumCalculation, ResponseChecksumValidation } from "./constants";
+export const flexibleChecksumsInputMiddlewareOptions = {
+    name: "flexibleChecksumsInputMiddleware",
+    toMiddleware: "serializerMiddleware",
+    relation: "before",
+    tags: ["BODY_CHECKSUM"],
+    override: true,
+};
+export const flexibleChecksumsInputMiddleware = (config, middlewareConfig) => (next, context) => async (args) => {
+    const input = args.input;
+    const { requestValidationModeMember } = middlewareConfig;
+    const requestChecksumCalculation = await config.requestChecksumCalculation();
+    const responseChecksumValidation = await config.responseChecksumValidation();
+    switch (requestChecksumCalculation) {
+        case RequestChecksumCalculation.WHEN_REQUIRED:
+            setFeature(context, "FLEXIBLE_CHECKSUMS_REQ_WHEN_REQUIRED", "a");
+            break;
+        case RequestChecksumCalculation.WHEN_SUPPORTED:
+            setFeature(context, "FLEXIBLE_CHECKSUMS_REQ_WHEN_SUPPORTED", "Z");
+            break;
+    }
+    switch (responseChecksumValidation) {
+        case ResponseChecksumValidation.WHEN_REQUIRED:
+            setFeature(context, "FLEXIBLE_CHECKSUMS_RES_WHEN_REQUIRED", "c");
+            break;
+        case ResponseChecksumValidation.WHEN_SUPPORTED:
+            setFeature(context, "FLEXIBLE_CHECKSUMS_RES_WHEN_SUPPORTED", "b");
+            break;
+    }
+    if (requestValidationModeMember && !input[requestValidationModeMember]) {
+        if (responseChecksumValidation === ResponseChecksumValidation.WHEN_SUPPORTED) {
+            input[requestValidationModeMember] = "ENABLED";
+        }
+    }
+    return next(args);
+};