@nordicsemiconductor/pc-nrfconnect-shared 60.0.0-pre1 → 60.0.0-pre2

package/src/Device/dfu-cc.ts

@@ -1,162 +0,0 @@
-/*
- * Copyright (c) 2021 Nordic Semiconductor ASA
- *
- * SPDX-License-Identifier: LicenseRef-Nordic-4-Clause
- */
-
-import * as $protobuf from 'protobufjs/light';
-
-const $root = (
-    $protobuf.roots.default || ($protobuf.roots.default = new $protobuf.Root())
-).addJSON({
-    dfu: {
-        nested: {
-            OpCode: {
-                values: {
-                    RESET: 0,
-                    INIT: 1,
-                },
-            },
-            FwType: {
-                values: {
-                    APPLICATION: 0,
-                    SOFTDEVICE: 1,
-                    BOOTLOADER: 2,
-                    SOFTDEVICE_BOOTLOADER: 3,
-                },
-            },
-            HashType: {
-                values: {
-                    NO_HASH: 0,
-                    CRC: 1,
-                    SHA128: 2,
-                    SHA256: 3,
-                    SHA512: 4,
-                },
-            },
-            Hash: {
-                fields: {
-                    hashType: {
-                        rule: 'required',
-                        type: 'HashType',
-                        id: 1,
-                    },
-                    hash: {
-                        rule: 'required',
-                        type: 'bytes',
-                        id: 2,
-                    },
-                },
-            },
-            InitCommand: {
-                fields: {
-                    fwVersion: {
-                        type: 'uint32',
-                        id: 1,
-                    },
-                    hwVersion: {
-                        type: 'uint32',
-                        id: 2,
-                    },
-                    sdReq: {
-                        rule: 'repeated',
-                        type: 'uint32',
-                        id: 3,
-                    },
-                    type: {
-                        type: 'FwType',
-                        id: 4,
-                    },
-                    sdSize: {
-                        type: 'uint32',
-                        id: 5,
-                    },
-                    blSize: {
-                        type: 'uint32',
-                        id: 6,
-                    },
-                    appSize: {
-                        type: 'uint32',
-                        id: 7,
-                    },
-                    hash: {
-                        type: 'Hash',
-                        id: 8,
-                    },
-                    isDebug: {
-                        type: 'bool',
-                        id: 9,
-                        options: {
-                            default: false,
-                        },
-                    },
-                },
-            },
-            ResetCommand: {
-                fields: {
-                    timeout: {
-                        rule: 'required',
-                        type: 'uint32',
-                        id: 1,
-                    },
-                },
-            },
-            Command: {
-                fields: {
-                    opCode: {
-                        type: 'OpCode',
-                        id: 1,
-                    },
-                    init: {
-                        type: 'InitCommand',
-                        id: 2,
-                    },
-                    reset: {
-                        type: 'ResetCommand',
-                        id: 3,
-                    },
-                },
-            },
-            SignatureType: {
-                values: {
-                    ECDSA_P256_SHA256: 0,
-                    ED25519: 1,
-                },
-            },
-            SignedCommand: {
-                fields: {
-                    command: {
-                        rule: 'required',
-                        type: 'Command',
-                        id: 1,
-                    },
-                    signatureType: {
-                        rule: 'required',
-                        type: 'SignatureType',
-                        id: 2,
-                    },
-                    signature: {
-                        rule: 'required',
-                        type: 'bytes',
-                        id: 3,
-                    },
-                },
-            },
-            Packet: {
-                fields: {
-                    command: {
-                        type: 'Command',
-                        id: 1,
-                    },
-                    signedCommand: {
-                        type: 'SignedCommand',
-                        id: 2,
-                    },
-                },
-            },
-        },
-    },
-});
-
-// export { $root as default };
-export default $root;

package/src/Device/initPacket.ts

@@ -1,402 +0,0 @@
-/*
- * Copyright (c) 2015 Nordic Semiconductor ASA
- *
- * SPDX-License-Identifier: LicenseRef-Nordic-4-Clause
- */
-
-import protobuf from 'protobufjs';
-
-import dfuCcProto from './dfu-cc';
-
-const root = protobuf.Root.fromJSON(dfuCcProto);
-
-export enum FwType {
-    APPLICATION,
-    SOFTDEVICE,
-    BOOTLOADER,
-    SOFTDEVICE_BOOTLOADER,
-}
-
-export enum HashType {
-    NO_HASH,
-    CRC,
-    SHA128,
-    SHA256,
-    SHA512,
-}
-
-export const OpCode = {
-    RESET: 0,
-    INIT: 1,
-};
-
-export const SignatureType = {
-    ECDSA_P256_SHA256: 0,
-    ED25519: 1,
-};
-
-export interface InitPacket {
-    fwVersion?: number;
-    hwVersion?: number;
-    sdReq?: number[];
-    fwType?: number;
-    sdSize: number;
-    blSize: number;
-    appSize: number;
-    hashType: number;
-    hash?: Buffer;
-    isDebug: boolean;
-    signatureType?: number;
-    signature?: [];
-}
-
-export const defaultInitPacket: InitPacket = {
-    fwVersion: 0xffffffff,
-    hwVersion: undefined,
-    sdReq: undefined,
-    fwType: undefined,
-    sdSize: 0,
-    blSize: 0,
-    appSize: 0,
-    hashType: HashType.NO_HASH,
-    hash: undefined,
-    isDebug: true,
-    signatureType: undefined,
-    signature: undefined,
-};
-
-export interface DfuImage {
-    name: string;
-    initPacket: InitPacket;
-    firmwareImage: Buffer;
-}
-
-// Create hash by using hash type and bytes
-const createHash = (hashType: number, hashInput: Buffer): protobuf.Message => {
-    const hashMessage = root.lookupType('dfu.Hash');
-    const hashPayload = {
-        hashType,
-        hash: hashInput,
-    };
-    const hash = hashMessage.create(hashPayload);
-
-    return hash;
-};
-
-// Create reset command
-const createResetCommand = (timeout: number): protobuf.Message => {
-    const resetCommandMessage = root.lookupType('dfu.ResetCommand');
-    const resetCommandPayload = {
-        timeout,
-    };
-    const resetCommand = resetCommandMessage.create(resetCommandPayload);
-
-    return resetCommand;
-};
-
-// Create init command
-const createInitCommand = (
-    fwVersion: number | undefined,
-    hwVersion: number | undefined,
-    sdReq: number[] | undefined,
-    type: number | undefined,
-    sdSize: number | undefined,
-    blSize: number | undefined,
-    appSize: number | undefined,
-    hash: protobuf.Message | undefined,
-    isDebug = false
-): protobuf.Message => {
-    const initCommandMessage = root.lookupType('dfu.InitCommand');
-    const initCommandPayload = {
-        ...defaultInitPacket,
-        fwVersion,
-        hwVersion,
-        sdReq,
-        type: type || FwType.APPLICATION,
-        sdSize,
-        blSize,
-        appSize,
-        hash,
-        isDebug,
-    };
-
-    return initCommandMessage.create(initCommandPayload);
-};
-
-// Create command
-const createCommand = (
-    opCode: number,
-    commandInput: protobuf.Message
-): protobuf.Message => {
-    const commandMessage = root.lookupType('dfu.Command');
-    const commandPayload = {
-        opCode,
-        [opCode === OpCode.INIT ? 'init' : 'reset']: commandInput,
-    };
-    const command = commandMessage.create(commandPayload);
-
-    return command;
-};
-
-// Create signed command
-const createSignedCommand = (
-    command: protobuf.Message,
-    signatureType: number,
-    signature: []
-): protobuf.Message => {
-    const signedCommandMessage = root.lookupType('dfu.SignedCommand');
-    const signedCommandPayload = {
-        command,
-        signatureType,
-        signature,
-    };
-    const signedCommand = signedCommandMessage.create(signedCommandPayload);
-
-    return signedCommand;
-};
-
-// Create packet
-const createPacket = (
-    command: protobuf.Message,
-    isSigned: boolean
-): protobuf.Message => {
-    const packetPayload = {
-        [isSigned ? 'signedCommand' : 'command']: command,
-    };
-    const packetMessage = root.lookupType('dfu.Packet');
-    const packet = packetMessage.create(packetPayload);
-
-    return packet;
-};
-
-// Convert protocol buffer message to buffer
-const messageToBuffer = (type: string, message: protobuf.Message) => {
-    if (!message) {
-        throw Error('The message to be converted is undefined.');
-    }
-
-    const dfuMessage = root.lookup(`dfu.${type}`) as protobuf.Type;
-    if (!dfuMessage) {
-        throw Error('DFU type not found.');
-    }
-
-    const buffer = dfuMessage.encode(message).finish();
-
-    return buffer as Buffer;
-};
-
-/**
- * Create reset command packet
- *
- * @param {Integer} timeout         the timeout for reset
- * @param {Integer} signatureType   the type of signature
- * @param {Array}   signature       the signature in bytes
- *
- * @returns {protobuf.Message | undefined} reset command packet
- */
-export const createResetPacket = (
-    timeout: number,
-    signatureType: number,
-    signature: []
-): protobuf.Message => {
-    // Check input parameters
-    if (timeout === undefined) {
-        throw new Error('Timeout is not set');
-    }
-
-    // It checks both null and undefined here
-    if (
-        (signatureType == null && signature != null) ||
-        (signatureType != null && signature == null)
-    ) {
-        throw new Error('Either signature type or signature is not set');
-    }
-
-    // Create reset command
-    const resetCommand = createResetCommand(timeout);
-    let isSigned = false;
-    let command = createCommand(OpCode.RESET, resetCommand);
-
-    // Create signed command if it is signed
-    // It checks both null and undefined here
-    if (signatureType != null && signature != null) {
-        isSigned = true;
-        command = createSignedCommand(command, signatureType, signature);
-    }
-
-    // Create packet
-    const packet = createPacket(command, isSigned);
-
-    return packet;
-};
-
-/**
- * Create reset command buffer
- *
- * @param {Integer} timeout         the timeout for reset
- * @param {Integer} signatureType   the type of signature
- * @param {Array}   signature       the signature in bytes
- *
- * @returns {Uint8Array} converted from reset command packet
- */
-export const createResetPacketBuffer = (
-    timeout: number,
-    signatureType: number,
-    signature: []
-): Uint8Array => {
-    const packet = createResetPacket(timeout, signatureType, signature);
-    const buffer = messageToBuffer('Packet', packet);
-
-    return buffer;
-};
-
-/**
- * Create init command packet
- *
- * @param {Integer}         fwVersion       the firmware version
- * @param {Integer}         hwVersion       the hardware version
- * @param {Array}           sdReq           the softdevice requirements
- * @param {FwType}          fwType          the firmware type
- * @param {Integer}         sdSize          the size of softDevice
- * @param {Integer}         blSize          the size of bootloader
- * @param {Integer}         appSize         the size of application
- * @param {HashType}        hashType        the type of hash
- * @param {Array}           hash            the hash in bytes
- * @param {Boolean}         isDebug         whether it is in debug mode or not
- * @param {SignatureType}   signatureType   the type of signature
- * @param {Array}           signature       the signature in bytes
- *
- * @returns {protobuf.Message} init command packet
- */
-export const createInitPacket = (
-    fwVersion: number | undefined,
-    hwVersion: number | undefined,
-    sdReq: number[] | undefined,
-    fwType: number | undefined,
-    sdSize: number | undefined,
-    blSize: number | undefined,
-    appSize: number | undefined,
-    hashType: number | undefined,
-    hash: Buffer | undefined,
-    isDebug: boolean,
-    signatureType: number | undefined,
-    signature: [] | undefined
-): protobuf.Message => {
-    // It checks both null and undefined here
-    if (
-        (signatureType == null && signature != null) ||
-        (signatureType != null && signature == null)
-    ) {
-        throw new Error('Either signature type or signature is not set');
-    }
-
-    // Create init command
-    const hashInput = createHash(
-        hashType || HashType.NO_HASH,
-        hash ?? Buffer.from([])
-    );
-    const initCommand = createInitCommand(
-        fwVersion,
-        hwVersion,
-        sdReq,
-        fwType,
-        sdSize,
-        blSize,
-        appSize,
-        hashInput,
-        isDebug
-    );
-    let command = createCommand(OpCode.INIT, initCommand);
-    let isSigned = false;
-
-    // Create signed command if it is signed
-    if (signatureType != null && signature != null) {
-        command = createSignedCommand(command, signatureType, signature);
-        isSigned = true;
-    }
-
-    // Create packet
-    const packet = createPacket(command, isSigned);
-
-    return packet;
-};
-
-/**
- * Create init command buffer
- *
- * @param {Integer}         fwVersion       the firmware version
- * @param {Integer}         hwVersion       the hardware version
- * @param {Array}           sdReq           the softdevice requirements
- * @param {FwType}          fwType          the firmware type
- * @param {Integer}         sdSize          the size of softdevice
- * @param {Integer}         blSize          the size of bootloader
- * @param {Integer}         appSize         the size of application
- * @param {HashType}        hashType        the type of hash
- * @param {Array}           hash            the hash in bytes
- * @param {Boolean}         isDebug         whether it is in debug mode or not
- * @param {SignatureType}   signatureType   the type of signature
- * @param {Array}           signature       the signature in bytes
- *
- * @returns {Uint8Array} converted from init command packet
- */
-export const createInitPacketBuffer = (
-    fwVersion: number,
-    hwVersion: number,
-    sdReq: number[],
-    fwType: number,
-    sdSize: number,
-    blSize: number,
-    appSize: number,
-    hashType: number,
-    hash: Buffer,
-    isDebug: boolean,
-    signatureType: number,
-    signature: []
-): Buffer => {
-    const packet = createInitPacket(
-        fwVersion,
-        hwVersion,
-        sdReq,
-        fwType,
-        sdSize,
-        blSize,
-        appSize,
-        hashType,
-        hash,
-        isDebug,
-        signatureType,
-        signature
-    );
-    const buffer = messageToBuffer('Packet', packet);
-
-    return buffer;
-};
-
-/**
- * Create init command packet Uint8Array
- *
- * @param {InitPacket} packetParams the InitPacket which carries all information
- *
- * @returns {Uint8Array} converted from init command packet buffer
- */
-export const createInitPacketUint8Array = (
-    packetParams: InitPacket
-): Uint8Array => {
-    const packet = createInitPacket(
-        packetParams.fwVersion,
-        packetParams.hwVersion,
-        packetParams.sdReq,
-        packetParams.fwType,
-        packetParams.sdSize,
-        packetParams.blSize,
-        packetParams.appSize,
-        packetParams.hashType,
-        packetParams.hash,
-        packetParams.isDebug,
-        packetParams.signatureType,
-        packetParams.signature
-    );
-    const buffer = messageToBuffer('Packet', packet);
-
-    return new Uint8Array(buffer);
-};