Initial import

This commit is contained in:
BTChip 2016-06-01 21:32:18 +02:00
parent 843dca6280
commit e0ccb379ed
69 changed files with 10991 additions and 0 deletions

7
.gitignore vendored Normal file
View File

@ -0,0 +1,7 @@
bin
debug
dep
obj
src/u2f_crypto_data.h

171
Makefile Executable file
View File

@ -0,0 +1,171 @@
#*******************************************************************************
# Ledger Blue
# (c) 2016 Ledger
#
# 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.
#*******************************************************************************
APPNAME = BTC
################
# Default rule #
################
all: default
# consider every intermediate target as final to avoid deleting intermediate files
.SECONDARY:
# disable builtin rules that overload the build process (and the debug log !!)
.SUFFIXES:
MAKEFLAGS += -r
SHELL = /bin/bash
#.ONESHELL:
############
# Platform #
############
PROG := token
CONFIG_PRODUCTIONS := bin/$(PROG)
SOURCE_PATH := src $(BOLOS_SDK)/src src_usb
SOURCE_FILES := $(foreach path, $(SOURCE_PATH),$(shell find $(path) | grep -E "\.c$$|\.s") )
INCLUDES_PATH := src_usb $(dir $(shell find src_usb/ | grep "\.h$$")) include src $(BOLOS_SDK)/include $(BOLOS_SDK)/include/arm
### platform definitions
DEFINES := ST31 gcc __IO=volatile
DEFINES += OS_IO_SEPROXYHAL IO_SEPROXYHAL_BUFFER_SIZE_B=300
DEFINES += HAVE_BAGL HAVE_PRINTF
DEFINES += HAVE_IO_USB HAVE_L4_USBLIB IO_USB_MAX_ENDPOINTS=7 IO_HID_EP_LENGTH=64
DEFINES += HAVE_BLE
DEFINES += LEDGER_MAJOR_VERSION=1 LEDGER_MINOR_VERSION=0 LEDGER_PATCH_VERSION=0 TCS_LOADER_PATCH_VERSION=0
##############
# Compiler #
##############
GCCPATH := $(BOLOS_ENV)/gcc-arm-none-eabi-5_3-2016q1/bin/
CLANGPATH := $(BOLOS_ENV)/clang-arm-fropi/bin
CC := $(CLANGPATH)/clang
CFLAGS_SHARED :=
CFLAGS_SHARED += -gdwarf-2 -gstrict-dwarf
CFLAGS_SHARED += -mcpu=cortex-m0 -mthumb
CFLAGS_SHARED += -fno-common -mtune=cortex-m0 -mlittle-endian
CFLAGS_SHARED += -std=gnu99 -Werror=int-to-pointer-cast -Wall -Wextra #-save-temps
CFLAGS_SHARED += -fdata-sections -ffunction-sections -funsigned-char -fshort-enums
CFLAGS_SHARED += -mno-unaligned-access
CFLAGS_SHARED += -Wno-unused-parameter -Wno-duplicate-decl-specifier
CFLAGS_SHARED += -fropi --target=armv6m-none-eabi
#CFLAGS += -finline-limit-0 -funsigned-bitfields
CFLAGS_NONOPT := -O0 $(CFLAGS_SHARED)
CFLAGS_OPT := -O3 $(CFLAGS_SHARED)
AS := $(GCCPATH)/arm-none-eabi-gcc
AFLAGS += -ggdb2 -O3 -Os -mcpu=cortex-m0 -fno-common -mtune=cortex-m0
# NOT SUPPORTED BY STM3L152 CFLAGS += -fpack-struct
#-pg --coverage
LD := $(GCCPATH)/arm-none-eabi-gcc
LDFLAGS :=
LDFLAGS += -gdwarf-2 -gstrict-dwarf
#LDFLAGS += -O0 -g3
LDFLAGS += -O3 -Os
#LDFLAGS += -O0
LDFLAGS += -Wall
LDFLAGS += -mcpu=cortex-m0 -mthumb
LDFLAGS += -fno-common -ffunction-sections -fdata-sections -fwhole-program -nostartfiles
LDFLAGS += -mno-unaligned-access
#LDFLAGS += -nodefaultlibs
#LDFLAGS += -nostdlib -nostdinc
LDFLAGS += -Tscript.ld -Wl,--gc-sections -Wl,-Map,debug/$(PROG).map,--cref
LDLIBS += -Wl,--library-path -Wl,$(GCCPATH)/../lib/armv6-m/
#LDLIBS += -Wl,--start-group
LDLIBS += -lm -lgcc -lc
#LDLIBS += -Wl,--end-group
# -mno-unaligned-access
#-pg --coverage
### computed variables
VPATH := $(dir $(SOURCE_FILES))
OBJECT_FILES := $(sort $(addprefix obj/, $(addsuffix .o, $(basename $(notdir $(SOURCE_FILES))))))
DEPEND_FILES := $(sort $(addprefix dep/, $(addsuffix .d, $(basename $(notdir $(SOURCE_FILES))))))
ifeq ($(filter clean,$(MAKECMDGOALS)),)
-include $(DEPEND_FILES)
endif
clean:
rm -fr obj bin debug dep
prepare:
@mkdir -p bin obj debug dep
.SECONDEXPANSION:
# default is not to display make commands
log = $(if $(strip $(VERBOSE)),$1,@$1)
default: prepare bin/$(PROG)
load:
python -m ledgerblue.loadApp --appFlags 0xC0 --fileName bin/$(PROG).hex --appName $(APPNAME)
delete:
python -m ledgerblue.deleteApp --appName $(APPNAME)
bin/$(PROG): $(OBJECT_FILES) script.ld
@echo "[LINK] $@"
$(call log,$(call link_cmdline,$(OBJECT_FILES) $(LDLIBS),$@))
$(call log,$(GCCPATH)/arm-none-eabi-objcopy -O ihex -S bin/$(PROG) bin/$(PROG).hex)
$(call log,mv bin/$(PROG) bin/$(PROG).elf)
$(call log,cp bin/$(PROG).elf obj)
$(call log,$(GCCPATH)/arm-none-eabi-objdump -S -d bin/$(PROG).elf > debug/$(PROG).asm)
dep/%.d: %.c Makefile
@echo "[DEP] $@"
@mkdir -p dep
$(call log,$(call dep_cmdline,$(INCLUDES_PATH), $(DEFINES),$<,$@))
obj/%.o: %.c dep/%.d
@echo "[CC] $@"
$(call log,$(call cc_cmdline,$(INCLUDES_PATH), $(DEFINES),$<,$@))
obj/%.o: %.s
@echo "[CC] $@"
$(call log,$(call as_cmdline,$(INCLUDES_PATH), $(DEFINES),$<,$@))
### BEGIN GCC COMPILER RULES
# link_cmdline(objects,dest) Macro that is used to format arguments for the linker
link_cmdline = $(LD) $(LDFLAGS) -o $(2) $(1)
# dep_cmdline(include,defines,src($<),dest($@)) Macro that is used to format arguments for the dependency creator
dep_cmdline = $(CC) -M $(CFLAGS) $(addprefix -D,$(2)) $(addprefix -I,$(1)) $(3) | sed 's/\($*\)\.o[ :]*/obj\/\1.o: /g' | sed -e 's/[:\t ][^ ]\+\.c//g' > dep/$(basename $(notdir $(4))).d 2>/dev/null
# cc_cmdline(include,defines,src,dest) Macro that is used to format arguments for the compiler
cc_cmdline = $(CC) -c $(CFLAGS_NONOPT) $(addprefix -D,$(2)) $(addprefix -I,$(1)) -o $(4) $(3)
cc_cmdline_opt = $(CC) -c $(CFLAGS_OPT) $(addprefix -D,$(2)) $(addprefix -I,$(1)) -o $(4) $(3)
as_cmdline = $(AS) -c $(AFLAGS) $(addprefix -D,$(2)) $(addprefix -I,$(1)) -o $(4) $(3)
### END GCC COMPILER RULES

View File

@ -1,2 +1,7 @@
# blue-app-btc
Bitcoin wallet application for Ledger Blue
This follows the beta specification at https://ledgerhq.github.io/btchip-doc/bitcoin-technical-beta.html - with the regular set of APDUs for standard wallet operations enabled.
Can be tested quickly tested with the Python API at https://github.com/LedgerHQ/btchip-python and Electrum (force noPin = True in getClient in plugins/ledger/ledger.py)

7
TODO.md Normal file
View File

@ -0,0 +1,7 @@
# BTC Application TODOs
- [ ] Sign message support
- [ ] Altcoins fixes (signing message format, prompts)
- [ ] Support an arbitrary number of TX outputs
- [ ] Support device / PIN locking in next firmware update

33
include/btchip.h Normal file
View File

@ -0,0 +1,33 @@
/*******************************************************************************
* Ledger Blue - Bitcoin Wallet
* (c) 2016 Ledger
*
* 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.
********************************************************************************/
#ifndef BTCHIP_H
#define BTCHIP_H
#include "btchip_config.h"
#include "os.h"
#define L_DEBUG_APP(x)
#define L_DEBUG_NOPREFIX(x)
#define L_DEBUG_BUF(x)
#define SW_TECHNICAL_DETAILS(x) BTCHIP_SW_TECHNICAL_PROBLEM
#include "btchip_secure_value.h"
#endif

View File

@ -0,0 +1,159 @@
/*******************************************************************************
* Ledger Blue - Bitcoin Wallet
* (c) 2016 Ledger
*
* 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.
********************************************************************************/
#ifndef BTCHIP_APDU_CONSTANTS_H
#define BTCHIP_APDU_CONSTANTS_H
#define BTCHIP_CLA 0xE0
#define BTCHIP_ADM_CLA 0xD0
#define BTCHIP_NFCPAYMENT_CLA 0xF0
#define BTCHIP_INS_SETUP 0x20
#define BTCHIP_INS_VERIFY_PIN 0x22
#define BTCHIP_INS_GET_OPERATION_MODE 0x24
#define BTCHIP_INS_SET_OPERATION_MODE 0x26
#define BTCHIP_INS_SET_KEYBOARD_CFG 0x28
#define BTCHIP_INS_GET_WALLET_PUBLIC_KEY 0x40
#define BTCHIP_INS_GET_TRUSTED_INPUT 0x42
#define BTCHIP_INS_HASH_INPUT_START 0x44
#define BTCHIP_INS_HASH_INPUT_FINALIZE 0x46
#define BTCHIP_INS_HASH_SIGN 0x48
#define BTCHIP_INS_HASH_INPUT_FINALIZE_FULL 0x4A
#define BTCHIP_INS_GET_INTERNAL_CHAIN_INDEX 0x4C
#define BTCHIP_INS_SIGN_MESSAGE 0x4E
#define BTCHIP_INS_GET_TRANSACTION_LIMIT 0xA0
#define BTCHIP_INS_SET_TRANSACTION_LIMIT 0xA2
#define BTCHIP_INS_IMPORT_PRIVATE_KEY 0xB0
#define BTCHIP_INS_GET_PUBLIC_KEY 0xB2
#define BTCHIP_INS_DERIVE_BIP32_KEY 0xB4
#define BTCHIP_INS_SIGNVERIFY_IMMEDIATE 0xB6
#define BTCHIP_INS_GET_RANDOM 0xC0
#define BTCHIP_INS_GET_ATTESTATION 0xC2
#define BTCHIP_INS_GET_FIRMWARE_VERSION 0xC4
#define BTCHIP_INS_COMPOSE_MOFN_ADDRESS 0xC6
#define BTCHIP_INS_GET_POS_SEED 0xCA
#define BTCHIP_INS_DEBUG 0xD0
#define BTCHIP_INS_ADM_INIT_KEYS 0x20
#define BTCHIP_INS_ADM_INIT_ATTESTATION 0x22
#define BTCHIP_INS_ADM_GET_UPDATE_ID 0x24
#define BTCHIP_INS_ADM_SET_KEYCARD_SEED 0x26
#define BTCHIP_INS_ADM_FIRMWARE_UPDATE 0x42
#define BTCHIP_INS_SET_USER_KEYCARD 0x10
#define BTCHIP_INS_SETUP_SECURE_SCREEN 0x12
#define BTCHIP_INS_SET_ALTERNATE_COIN_VER 0x14
#define BTCHIP_INS_STORE_TRUST_ROOT_BIP70 0x30
#define BTCHIP_INS_CREATE_CERTIFICATE_BIP70 0x32
#define BTCHIP_INS_CREATE_PAYMENT_REQ_BIP70 0x34
#define BTCHIP_INS_PROCESS_CERTIFICATE_BIP70 0x36
#define BTCHIP_INS_PARSE_PAYMENT_REQ_BIP70 0x38
#define BTCHIP_INS_HASH_INPUT_FINALIZE_BIP70 0x3A
#define BTCHIP_INS_ADM_SET_ROOT_BIP70 0x28
#define BTCHIP_INS_ADM_SET_BIP39_SHUFFLE 0x2A
#define BTCHIP_INS_NFCPAYMENT_SET_CONFIG 0x20
#define BTCHIP_INS_NFCPAYMENT_GET_CONFIG 0x22
#define BTCHIP_INS_NFCPAYMENT_STORE_UTXO 0x40
#define BTCHIP_INS_NFCPAYMENT_STORE_SCRIPT 0x42
#define BTCHIP_INS_NFCPAYMENT_GET_UTXO 0x44
#define BTCHIP_INS_NFCPAYMENT_DELETE_UTXO 0x46
#define BTCHIP_INS_NFCPAYMENT_GET_PAYMENT_TX 0x50
#define BTCHIP_INS_NFCPAYMENT_GET_LAST_TX 0x52
#define BTCHIP_INS_NFCPAYMENT_CONFIRM_TX 0x54
#define BTCHIP_INS_NFCPAYMENT_CONFIRM_CHANGE 0x56
#define BTCHIP_INS_NFCPAYMENT_GET_LAST_STAT 0x58
#define BTCHIP_INS_NFCPAYMENT_GET_DATA 0xC0
#define BTCHIP_SW_PIN_REMAINING_ATTEMPTS 0x63C0
#define BTCHIP_SW_INCORRECT_LENGTH 0x6700
#define BTCHIP_SW_COMMAND_INCOMPATIBLE_FILE_STRUCTURE 0x6981
#define BTCHIP_SW_SECURITY_STATUS_NOT_SATISFIED 0x6982
#define BTCHIP_SW_CONDITIONS_OF_USE_NOT_SATISFIED 0x6985
#define BTCHIP_SW_INCORRECT_DATA 0x6A80
#define BTCHIP_SW_NOT_ENOUGH_MEMORY_SPACE 0x6A84
#define BTCHIP_SW_REFERENCED_DATA_NOT_FOUND 0x6A88
#define BTCHIP_SW_FILE_ALREADY_EXISTS 0x6A89
#define BTCHIP_SW_INCORRECT_P1_P2 0x6B00
#define BTCHIP_SW_INS_NOT_SUPPORTED 0x6D00
#define BTCHIP_SW_CLA_NOT_SUPPORTED 0x6E00
#define BTCHIP_SW_TECHNICAL_PROBLEM 0x6F00
#define BTCHIP_SW_OK 0x9000
#define BTCHIP_SW_MEMORY_PROBLEM 0x9240
#define BTCHIP_SW_NO_EF_SELECTED 0x9400
#define BTCHIP_SW_INVALID_OFFSET 0x9402
#define BTCHIP_SW_FILE_NOT_FOUND 0x9404
#define BTCHIP_SW_INCONSISTENT_FILE 0x9408
#define BTCHIP_SW_ALGORITHM_NOT_SUPPORTED 0x9484
#define BTCHIP_SW_INVALID_KCV 0x9485
#define BTCHIP_SW_CODE_NOT_INITIALIZED 0x9802
#define BTCHIP_SW_ACCESS_CONDITION_NOT_FULFILLED 0x9804
#define BTCHIP_SW_CONTRADICTION_SECRET_CODE_STATUS 0x9808
#define BTCHIP_SW_CONTRADICTION_INVALIDATION 0x9810
#define BTCHIP_SW_CODE_BLOCKED 0x9840
#define BTCHIP_SW_MAX_VALUE_REACHED 0x9850
#define BTCHIP_SW_GP_AUTH_FAILED 0x6300
#define BTCHIP_SW_LICENSING 0x6F42
#define BTCHIP_SW_HALTED 0x6FAA
#define BTCHIP_SW_APP_HALTED BTCHIP_SW_CONDITIONS_OF_USE_NOT_SATISFIED
#define ISO_OFFSET_CLA 0x00
#define ISO_OFFSET_INS 0x01
#define ISO_OFFSET_P1 0x02
#define ISO_OFFSET_P2 0x03
#define ISO_OFFSET_LC 0x04
#define ISO_OFFSET_CDATA 0x05
#define BTCHIP_2FA_NONE 0x00
#define BTCHIP_2FA_KEYBOARD 0x01
#define BTCHIP_2FA_SECURE_SCREEN 0x02
#define BITID_DERIVE 0xB11D
#define BITID_DERIVE_MULTIPLE 0xB11E
#include "os.h"
#include "btchip_secure_value.h"
void btchip_commit_operation_mode(secu8 operationMode);
unsigned short btchip_apdu_setup(void);
unsigned short btchip_apdu_verify_pin(void);
unsigned short btchip_apdu_get_operation_mode(void);
unsigned short btchip_apdu_set_operation_mode(void);
unsigned short btchip_apdu_get_wallet_public_key(void);
unsigned short btchip_apdu_get_trusted_input(void);
unsigned short btchip_apdu_hash_input_start(void);
unsigned short btchip_apdu_hash_input_finalize(void);
unsigned short btchip_apdu_hash_sign(void);
unsigned short btchip_apdu_hash_input_finalize_full(void);
unsigned short btchip_apdu_import_private_key(void);
unsigned short btchip_apdu_get_public_key(void);
unsigned short btchip_apdu_derive_bip32_key(void);
unsigned short btchip_apdu_signverify_immediate(void);
unsigned short btchip_apdu_sign_message(void);
unsigned short btchip_apdu_get_random(void);
unsigned short btchip_apdu_get_firmware_version(void);
unsigned short btchip_apdu_set_user_keycard(void);
unsigned short btchip_apdu_setup_secure_screen(void);
unsigned short btchip_apdu_set_alternate_coin_version(void);
#endif

27
include/btchip_base58.h Normal file
View File

@ -0,0 +1,27 @@
/*******************************************************************************
* Ledger Blue - Bitcoin Wallet
* (c) 2016 Ledger
*
* 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.
********************************************************************************/
#ifndef BTCHIP_BASE58_H
#define BTCHIP_BASE58_H
unsigned char btchip_decode_base58(unsigned char WIDE *in, unsigned char length,
unsigned char *out, unsigned char maxoutlen);
unsigned char btchip_encode_base58(unsigned char WIDE *in, unsigned char length,
unsigned char *out, unsigned char maxoutlen);
#endif

25
include/btchip_bcd.h Normal file
View File

@ -0,0 +1,25 @@
/*******************************************************************************
* Ledger Blue - Bitcoin Wallet
* (c) 2016 Ledger
*
* 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.
********************************************************************************/
#ifndef BTCHIP_BCD_H
#define BTCHIP_BCD_H
unsigned char
btchip_convert_hex_amount_to_displayable(unsigned char WIDE *amount);
#endif

28
include/btchip_config.h Normal file
View File

@ -0,0 +1,28 @@
/*******************************************************************************
* Ledger Blue - Bitcoin Wallet
* (c) 2016 Ledger
*
* 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.
********************************************************************************/
#ifndef BTCHIP_CONFIG_H
#define BTCHIP_CONFIG_H
//#define DISABLE_SECURE_VALUE
#define VERBOSE_6F
#define os_crc cx_crc16
#endif

203
include/btchip_context.h Normal file
View File

@ -0,0 +1,203 @@
/*******************************************************************************
* Ledger Blue - Bitcoin Wallet
* (c) 2016 Ledger
*
* 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.
********************************************************************************/
#ifndef BTCHIP_CONTEXT_H
#define BTCHIP_CONTEXT_H
#include "os.h"
#include "btchip_secure_value.h"
#include "btchip_filesystem_tx.h"
#define MAX_OUTPUT_TO_CHECK 500
#define MAGIC_TRUSTED_INPUT 0x32
#define MAGIC_DEV_KEY 0x01
enum btchip_modes_e {
BTCHIP_MODE_ISSUER = 0x00,
BTCHIP_MODE_SETUP_NEEDED = 0xff,
BTCHIP_MODE_WALLET = 0x01,
BTCHIP_MODE_RELAXED_WALLET = 0x02,
BTCHIP_MODE_SERVER = 0x04,
BTCHIP_MODE_DEVELOPER = 0x08,
};
enum btchip_options_e {
BTCHIP_OPTION_UNCOMPRESSED_KEYS = 0x01,
BTCHIP_OPTION_DETERMINISTIC_SIGNATURE = 0x02,
BTCHIP_OPTION_FREE_SIGHASHTYPE = 0x04,
BTCHIP_OPTION_SKIP_2FA_P2SH = 0x08,
BTCHIP_OPTION_ALLOW_ARBITRARY_CHANGE = 0x10
};
/**
* Current state of an untrusted transaction hashing
*/
enum btchip_transaction_state_e {
/** No transaction in progress */
BTCHIP_TRANSACTION_NONE = 0x00,
/** Transaction defined, waiting for an input to be hashed */
BTCHIP_TRANSACTION_DEFINED_WAIT_INPUT = 0x01,
/** Transaction defined, input hashing in progress, pending input script
data */
BTCHIP_TRANSACTION_INPUT_HASHING_IN_PROGRESS_INPUT_SCRIPT = 0x02,
/** Transaction defined, input hashing done, pending output hashing for this
input */
BTCHIP_TRANSACTION_INPUT_HASHING_DONE = 0x03,
/** Transaction defined, waiting for an output to be hashed */
BTCHIP_TRANSACTION_DEFINED_WAIT_OUTPUT = 0x04,
/** Transaction defined, output hashing in progress for a complex script,
pending output script data */
BTCHIP_TRANSACTION_OUTPUT_HASHING_IN_PROGRESS_OUTPUT_SCRIPT = 0x05,
/** Transaction defined, output hashing done, pending finalization */
BTCHIP_TRANSACTION_OUTPUT_HASHING_DONE = 0x06,
/** Transaction parsed */
BTCHIP_TRANSACTION_PARSED = 0x07,
/** Transaction parsed, ready to prepare for signature after validating the
user outputs */
BTCHIP_TRANSACTION_PRESIGN_READY = 0x08,
/** Transaction fully parsed, ready to be signed */
BTCHIP_TRANSACTION_SIGN_READY = 0x09,
};
typedef enum btchip_transaction_state_e btchip_transaction_state_t;
struct segwit_hash_s {
cx_sha256_t hashPrevouts;
cx_sha256_t hashSequence;
};
struct segwit_cache_s {
unsigned char hashedPrevouts[32];
unsigned char hashedSequence[32];
unsigned char hashedOutputs[32];
};
/**
* Structure defining an operation on a transaction
*/
struct btchip_transaction_context_s {
/** Transient over signing components */
/** Remaining number of inputs/outputs to process for this transaction */
unsigned long int transactionRemainingInputsOutputs;
/** Index of the currently processed input/output for this transaction */
unsigned long int transactionCurrentInputOutput;
/** Remaining script bytes to process for the current input or output */
unsigned long int scriptRemaining;
/** Persistent over signing components */
/** State of the transaction, type btchip_transaction_state_t */
unsigned char transactionState;
/** Computed sum of transaction inputs or value of the output to convert to
* a trusted input */
unsigned char transactionAmount[8];
/** Flag indicating if this transaction has been processed before */
unsigned char firstSigned;
/** If the transaction is relaxed */
unsigned char relaxed;
/** If the transaction consumes a P2SH input */
unsigned char consumeP2SH;
};
typedef struct btchip_transaction_context_s btchip_transaction_context_t;
struct btchip_tmp_output_s {
/** Change address if initialized */
unsigned char changeAddress[21];
/** Flag set if the change address was initialized */
unsigned char changeInitialized;
/** Flag set if the change address was checked */
unsigned char changeChecked;
/** Flag set if the change address can be submitted */
unsigned char changeAccepted;
/** Flag set if the outputs have been fragmented */
unsigned char multipleOutput;
/** Crc of the cleartext output */
unsigned short outputCrc;
};
typedef struct btchip_tmp_output_s btchip_tmp_output_t;
struct btchip_context_s {
/** Flag if dongle has been halted */
secu8 halted;
/** Index of the output to convert into a trusted input in a transaction */
unsigned long int trustedInputIndex;
/** (Integrity protected) transaction context */
btchip_transaction_context_t transactionContext;
/** Current Pay To Address version */
unsigned char payToAddressVersion;
/** Current Pay To Script Hash version */
unsigned char payToScriptHashVersion;
/** Non protected transaction context */
/** Full transaction hash context */
cx_sha256_t transactionHashFull;
/** Authorization transaction hash context */
cx_sha256_t transactionHashAuthorization;
/** Current hash to perform (TRANSACTION_HASH_) */
unsigned char transactionHashOption;
/* Segregated Witness changes */
union {
struct segwit_hash_s hash;
struct segwit_cache_s cache;
} segwit;
unsigned char transactionVersion[4];
unsigned char inputValue[8];
unsigned char usingSegwit;
unsigned char segwitParsedOnce;
/* /Segregated Witness changes */
/** Size currently available to the transaction parser */
unsigned char transactionDataRemaining;
/** Current pointer to the transaction buffer for the transaction parser */
unsigned char *transactionBufferPointer;
/** Trusted Input index processed */
unsigned char trustedInputProcessed;
/** Transaction input to catch for a Trusted Input lookup */
unsigned long int transactionTargetInput;
/** Length of the incoming command */
unsigned short inLength;
/** Length of the outgoing command */
unsigned short outLength;
/** Status Word of the response */
unsigned short sw;
/** Current scratch buffer */
unsigned char *tmp;
// was previously in NVRAM
btchip_transaction_summary_t transactionSummary;
union {
btchip_tmp_output_t output;
} tmpCtx;
unsigned char currentOutput[MAX_OUTPUT_TO_CHECK];
unsigned short currentOutputOffset;
};
typedef struct btchip_context_s btchip_context_t;
void btchip_context_init(void);
#endif

28
include/btchip_ecc.h Normal file
View File

@ -0,0 +1,28 @@
/*******************************************************************************
* Ledger Blue - Bitcoin Wallet
* (c) 2016 Ledger
*
* 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.
********************************************************************************/
#ifndef BTCHIP_ECC_H
#define BTCHIP_ECC_H
#include "os.h"
#define BTCHIP_CURVE CX_CURVE_256K1
void btchip_compress_public_key_value(unsigned char *value);
#endif

View File

@ -0,0 +1,63 @@
/*******************************************************************************
* Ledger Blue - Bitcoin Wallet
* (c) 2016 Ledger
*
* 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.
********************************************************************************/
#ifndef BTCHIP_FS_H
#define BTCHIP_FS_H
#include "os.h"
#include "btchip_config.h"
#include "btchip_context.h"
#include "btchip_filesystem_tx.h"
enum btchip_supported_modes_e {
BTCHIP_SUPPORTED_MODE_WALLET = 0x01,
BTCHIP_SUPPORTED_MODE_RELAXED_WALLET = 0x02,
BTCHIP_SUPPORTED_MODE_SERVER = 0x04,
BTCHIP_SUPPORTED_MODE_DEVELOPER = 0x08
};
struct btchip_config_s {
secu8 supportedModes;
secu8 operationMode;
unsigned char options;
unsigned char payToAddressVersion;
unsigned char payToScriptHashVersion;
};
typedef struct btchip_config_s btchip_config_t;
typedef struct btchip_backup_area_s {
btchip_config_t config;
// TODO : replace by AES key, review signature policy
cx_des_key_t trustedinput_key;
} btchip_backup_area_t;
typedef struct btchip_storage_s {
unsigned char storageInitialized;
unsigned char config_valid;
btchip_backup_area_t bkp;
} btchip_storage_t;
// the global nvram memory variable
extern btchip_storage_t const WIDE N_btchip;
void btchip_set_operation_mode(unsigned char operationMode);
#endif

View File

@ -0,0 +1,58 @@
/*******************************************************************************
* Ledger Blue - Bitcoin Wallet
* (c) 2016 Ledger
*
* 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.
********************************************************************************/
#ifndef BTCHIP_FS_TX_H
#define BTCHIP_FS_TX_H
#include "os.h"
#define MAX_BIP32_PATH 10
#define MAX_BIP32_PATH_LENGTH (4 * MAX_BIP32_PATH) + 1
struct btchip_transaction_summary_data_s {
unsigned char
transactionNonce[8]; // used to bind to the current set of inputs
unsigned char pin[4]; // transaction PIN
unsigned char hasChange;
unsigned char isP2sh;
unsigned char arbitraryChange;
unsigned char relaxed;
unsigned char outputAmount[8];
unsigned char fees[8]; // only in wallet mode
unsigned char changeAmount[8]; // only in wallet mode
unsigned char outputAddress[21]; // only in wallet mode
unsigned char changeAddress[21]; // only in wallet mode
unsigned char keyPath[MAX_BIP32_PATH_LENGTH];
};
typedef struct btchip_transaction_summary_data_s
btchip_transaction_summary_data_t;
struct btchip_transaction_summary_s {
unsigned char active;
#define ACTION_NONE 0
#define ACTION_REQUIRED 1
#define ACTION_DONE 2
unsigned char action;
unsigned char payToAddressVersion;
unsigned char payToScriptHashVersion;
unsigned char authorizationHash[32];
btchip_transaction_summary_data_t summarydata;
};
typedef struct btchip_transaction_summary_s btchip_transaction_summary_t;
#endif

84
include/btchip_helpers.h Normal file
View File

@ -0,0 +1,84 @@
/*******************************************************************************
* Ledger Blue - Bitcoin Wallet
* (c) 2016 Ledger
*
* 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.
********************************************************************************/
#ifndef BTCHIP_HELPERS_H
#define BTCHIP_HELPERS_H
#define OUTPUT_SCRIPT_REGULAR_PRE_LENGTH 4
#define OUTPUT_SCRIPT_REGULAR_POST_LENGTH 2
#define OUTPUT_SCRIPT_P2SH_PRE_LENGTH 3
#define OUTPUT_SCRIPT_P2SH_POST_LENGTH 1
unsigned char btchip_output_script_is_regular(unsigned char *buffer);
unsigned char btchip_output_script_is_p2sh(unsigned char *buffer);
unsigned char btchip_output_script_is_op_return(unsigned char *buffer);
void btchip_sleep16(unsigned short delay);
void btchip_sleep32(unsigned long int delayEach, unsigned long int delayRepeat);
unsigned long int btchip_read_u32(unsigned char WIDE *buffer, unsigned char be,
unsigned char skipSign);
void btchip_write_u32_be(unsigned char *buffer, unsigned long int value);
void btchip_write_u32_le(unsigned char *buffer, unsigned long int value);
void btchip_retrieve_keypair_discard(unsigned char WIDE *privateComponent,
unsigned char derivePublic);
void btchip_perform_double_hash(unsigned char WIDE *in, unsigned short inlen,
unsigned char *out,
unsigned char hash1Algorithm,
unsigned char hash2Algorithm);
void btchip_public_key_hash160(unsigned char WIDE *in, unsigned short inlen,
unsigned char *out);
unsigned short btchip_public_key_to_encoded_base58(
unsigned char WIDE *in, unsigned short inlen, unsigned char *out,
unsigned short outlen, unsigned char version, unsigned char alreadyHashed);
unsigned short btchip_decode_base58_address(unsigned char WIDE *in,
unsigned short inlen,
unsigned char *out,
unsigned short outlen);
void btchip_private_derive_keypair(unsigned char WIDE *bip32Path,
unsigned char derivePublic,
unsigned char *out_chainCode);
// void btchip_set_check_internal_structure_integrity(unsigned char
// setParameter);
#define btchip_set_check_internal_structure_integrity(x)
void btchip_swap_bytes(unsigned char *target, unsigned char *source,
unsigned char size);
void btchip_signverify_finalhash(void WIDE *keyContext, unsigned char sign,
unsigned char WIDE *in, unsigned short inlen,
unsigned char *out, unsigned short outlen,
unsigned char rfc6979);
void btchip_transaction_add_output(unsigned char *hash160Address,
unsigned char *amount, unsigned char p2sh);
unsigned char btchip_address_isP2SH(unsigned char version);
unsigned char btchip_address_isValid(unsigned char version);
unsigned char btchip_rng_u8_modulo(unsigned char modulo);
unsigned char btchip_secure_memcmp(const void WIDE *buf1, const void WIDE *buf2,
unsigned short length);
unsigned char btchip_decrease_2fa(void);
void btchip_reset_2fa(void);
void btchip_reset_token(void);
#endif

View File

@ -0,0 +1,31 @@
/*******************************************************************************
* Ledger Blue - Bitcoin Wallet
* (c) 2016 Ledger
*
* 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.
********************************************************************************/
#ifndef BTCHIP_PUBLIC_RAM_KEY_VARIABLES_H
#define BTCHIP_PUBLIC_RAM_KEY_VARIABLES_H
#include "btchip_config.h"
#include "btchip_secure_value.h"
#include "btchip_context.h"
extern cx_ecfp_public_key_t btchip_public_key_D;
extern cx_ecfp_private_key_t btchip_private_key_D;
#endif

View File

@ -0,0 +1,29 @@
/*******************************************************************************
* Ledger Blue - Bitcoin Wallet
* (c) 2016 Ledger
*
* 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.
********************************************************************************/
#ifndef BTCHIP_PUBLIC_RAM_VARIABLES_H
#define BTCHIP_PUBLIC_RAM_VARIABLES_H
#include "btchip_config.h"
#include "btchip_secure_value.h"
#include "btchip_context.h"
extern btchip_context_t btchip_context_D;
#endif

View File

@ -0,0 +1,50 @@
/*******************************************************************************
* Ledger Blue - Bitcoin Wallet
* (c) 2016 Ledger
*
* 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.
********************************************************************************/
#ifndef BTCHIP_SECURE_VALUE_H
#define BTCHIP_SECURE_VALUE_H
#include "os.h"
typedef unsigned short secu8;
typedef unsigned long int secu16;
void sbSet(secu8 *target, unsigned char source);
void sbCheck(secu8 source);
void ssSet(secu16 *target, unsigned short source);
void ssCheck(secu16 source);
#define SB_GET(x) ((unsigned char)x)
#define SB_SET(x, y) sbSet(&x, y);
#define SB_CHECK(x) sbCheck(x);
#define SS_GET(x) ((unsigned short)x)
#define SS_SET(x, y) ssSet(&x, y);
#define SS_CHECK(x) ssCheck(x);
#define SSEC_DEF(x) unsigned char x = 0;
#define SSEC_INC(x) x++;
#define SSEC_CHECK(x, value) \
if (x != value) \
reset();
#endif

159
script.ld Normal file
View File

@ -0,0 +1,159 @@
/*******************************************************************************
* Ledger Blue - Secure firmware
* (c) 2016 Ledger
*
* 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.
********************************************************************************/
/**
* Global chip memory layout and constants
*
*/
MEMORY
{
DISCARD (rwx) : ORIGIN = 0xd0000000, LENGTH = 1M
FLASH (rx) : ORIGIN = 0xc0d00000, LENGTH = 400K
SRAM (rwx) : ORIGIN = 0x20001800, LENGTH = 6K
}
PAGE_SIZE = 256;
STACK_SIZE = 2048;
END_STACK = ORIGIN(SRAM) + LENGTH(SRAM);
SECTIONS
{
ENTRY(main)
/****************************************************************/
/* This section locates the code in FLASH */
/****************************************************************/
/** put text in Flash memory, VMA will be equal to LMA */
.text :
{
/* provide start code symbol, shall be zero */
_text = .;
PROVIDE(_setjmp = setjmp); /*thanks clang*/
/* ensure main is always @ 0xC0D00000 */
*(.boot*)
/* place the other code and rodata defined BUT nvram variables that are displaced in a r/w area */
*(.text*)
*(EXCLUDE_FILE (*_nvram_*) .rodata*) /*.data.rel.ro* not here to detect invalid PIC usage */
. = ALIGN(4);
/* all code placed */
_etext = .;
. = ALIGN(PAGE_SIZE);
/* NVM data (ex-filesystem) */
*(.bss.N_*)
} > FLASH = 0x00
.data (NOLOAD):
{
. = ALIGN(4);
/**
* Place RAM initialized variables
*/
_data = .;
*(vtable)
*(.data*)
_edata = .;
} > DISCARD /*> SRAM AT>FLASH = 0x00 */
.bss :
{
/**
* Place RAM uninitialized variables
*/
_bss = .;
*(EXCLUDE_FILE (*_nvram_*) .bss*)
_ebss = .;
/**
* Reserve stack size
*/
_stack = .;
. = _stack + STACK_SIZE;
PROVIDE( _stack_size = STACK_SIZE );
PROVIDE( _estack = ABSOLUTE(END_STACK) );
} > SRAM = 0x00
.nvram :
{
/** Place other configuration */
*_nvram_*(.rodata*)
} > FLASH = 0x00
/****************************************************************/
/* DEBUG */
/****************************************************************/
/* remove the debugging information from the standard libraries */
DISCARD (NOLOAD) :
{
libc.a ( * )
libm.a ( * )
libgcc.a ( * )
*(.ARM.exidx* .gnu.linkonce.armexidx.*)
}
/* Stabs debugging sections. */
.stab 0 : { *(.stab) }
.stabstr 0 : { *(.stabstr) }
.stab.excl 0 : { *(.stab.excl) }
.stab.exclstr 0 : { *(.stab.exclstr) }
.stab.index 0 : { *(.stab.index) }
.stab.indexstr 0 : { *(.stab.indexstr) }
.comment 0 : { *(.comment) }
/* DWARF debug sections.
Symbols in the DWARF debugging sections are relative to the beginning
of the section so we begin them at 0. */
/* DWARF 1 */
.debug 0 : { *(.debug) }
.line 0 : { *(.line) }
/* GNU DWARF 1 extensions */
.debug_srcinfo 0 : { *(.debug_srcinfo) }
.debug_sfnames 0 : { *(.debug_sfnames) }
/* DWARF 1.1 and DWARF 2 */
.debug_aranges 0 : { *(.debug_aranges) }
.debug_pubnames 0 : { *(.debug_pubnames) }
/* DWARF 2 */
.debug_info 0 : { *(.debug_info .gnu.linkonce.wi.*) }
.debug_abbrev 0 : { *(.debug_abbrev) }
.debug_line 0 : { *(.debug_line) }
.debug_frame 0 : { *(.debug_frame) }
.debug_str 0 : { *(.debug_str) }
.debug_loc 0 : { *(.debug_loc) }
.debug_macinfo 0 : { *(.debug_macinfo) }
/* SGI/MIPS DWARF 2 extensions */
.debug_weaknames 0 : { *(.debug_weaknames) }
.debug_funcnames 0 : { *(.debug_funcnames) }
.debug_typenames 0 : { *(.debug_typenames) }
.debug_varnames 0 : { *(.debug_varnames) }
}

112
src/btchip.c Normal file
View File

@ -0,0 +1,112 @@
/*******************************************************************************
* Ledger Blue - Bitcoin Wallet
* (c) 2016 Ledger
*
* 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.
********************************************************************************/
#include "os.h"
#include "btchip_internal.h"
#include "btchip_apdu_constants.h"
#define BTCHIP_TECHNICAL_NOT_IMPLEMENTED 0x99
void app_main(void) {
os_memset(G_io_apdu_buffer, 0, 255); // paranoia
// Process the incoming APDUs
// first exchange, no out length :) only wait the apdu
btchip_context_D.outLength = 0;
for (;;) {
unsigned char cla;
unsigned char ins;
unsigned char dispatched;
L_DEBUG_APP(("Main Loop\n"));
// os_memset(G_io_apdu_buffer, 0, 255); // paranoia
// receive the whole apdu using the 7 bytes headers (ledger transport)
btchip_context_D.inLength =
io_exchange(CHANNEL_APDU | 0,
// use the previous outlength as the reply
btchip_context_D.outLength);
// nothing to reply for now
btchip_context_D.outLength = 0;
BEGIN_TRY {
TRY {
// If halted, then notify
SB_CHECK(btchip_context_D.halted);
if (SB_GET(btchip_context_D.halted)) {
btchip_context_D.sw = BTCHIP_SW_HALTED;
goto sendSW;
}
cla = G_io_apdu_buffer[ISO_OFFSET_CLA];
ins = G_io_apdu_buffer[ISO_OFFSET_INS];
for (dispatched = 0; dispatched < DISPATCHER_APDUS;
dispatched++) {
if ((cla == DISPATCHER_CLA[dispatched]) &&
(ins == DISPATCHER_INS[dispatched])) {
break;
}
}
if (dispatched == DISPATCHER_APDUS) {
btchip_context_D.sw = BTCHIP_SW_INS_NOT_SUPPORTED;
goto sendSW;
}
if (DISPATCHER_DATA_IN[dispatched]) {
if (G_io_apdu_buffer[ISO_OFFSET_LC] == 0x00 ||
btchip_context_D.inLength - 5 == 0) {
btchip_context_D.sw = BTCHIP_SW_INCORRECT_LENGTH;
goto sendSW;
}
// notify we ned to receive data
io_exchange(CHANNEL_APDU | IO_RECEIVE_DATA, 0);
}
// call the apdu handler
btchip_context_D.sw = ((apduProcessingFunction)PIC(
DISPATCHER_FUNCTIONS[dispatched]))();
sendSW:
// prepare SW after replied data
G_io_apdu_buffer[btchip_context_D.outLength] =
(btchip_context_D.sw >> 8);
G_io_apdu_buffer[btchip_context_D.outLength + 1] =
(btchip_context_D.sw & 0xff);
btchip_context_D.outLength += 2;
}
CATCH_OTHER(e) {
// uncaught exception detected
G_io_apdu_buffer[0] = 0x6F;
btchip_context_D.outLength = 2;
G_io_apdu_buffer[1] = e;
// we caught something suspicious
SB_SET(btchip_context_D.halted, 1);
}
FINALLY;
}
END_TRY;
// reply during reception of next apdu
}
L_DEBUG_APP(("End of main loop\n"));
// in case reached
reset();
}

View File

@ -0,0 +1,64 @@
/*******************************************************************************
* Ledger Blue - Bitcoin Wallet
* (c) 2016 Ledger
*
* 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.
********************************************************************************/
#include "btchip_internal.h"
#include "btchip_apdu_constants.h"
#define FEATURES_COMPRESSED_KEYS 0x01
#define FEATURES_SELF_SCREEN_BUTTONS 0x02
#define FEATURES_EXTERNAL_SCREEN_BUTTONS 0x04
#define FEATURES_NFC 0x08
#define FEATURES_BLE 0x10
#define FEATURES_TEE 0x20
#define MODE_SETUP 0x01
#define MODE_OPERATION 0x02
#define ARCH_ID 0x30
// Java Card is 0x60
void get_firmware_version(unsigned char *buffer) {
buffer[0] = ARCH_ID;
buffer[1] = LEDGER_MAJOR_VERSION;
buffer[2] = LEDGER_MINOR_VERSION;
buffer[3] = LEDGER_PATCH_VERSION;
buffer[4] = 1;
buffer[5] = TCS_LOADER_PATCH_VERSION;
}
unsigned short btchip_apdu_get_firmware_version() {
G_io_apdu_buffer[0] =
(((N_btchip.bkp.config.options & BTCHIP_OPTION_UNCOMPRESSED_KEYS) != 0)
? 0x00
: 0x01);
G_io_apdu_buffer[0] |= FEATURES_NFC;
G_io_apdu_buffer[0] |= FEATURES_BLE;
G_io_apdu_buffer[0] |= FEATURES_SELF_SCREEN_BUTTONS;
get_firmware_version(G_io_apdu_buffer + 1);
G_io_apdu_buffer[7] = 0x00;
G_io_apdu_buffer[7] |= MODE_SETUP;
G_io_apdu_buffer[7] |= MODE_OPERATION;
btchip_context_D.outLength = 0x08;
return BTCHIP_SW_OK;
}

View File

@ -0,0 +1,44 @@
/*******************************************************************************
* Ledger Blue - Bitcoin Wallet
* (c) 2016 Ledger
*
* 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.
********************************************************************************/
#include "btchip_internal.h"
#include "btchip_apdu_constants.h"
#define P1_GET_OPERATION_MODE 0x00
#define P1_GET_SECOND_FACTOR_MODE 0x01
unsigned short btchip_apdu_get_operation_mode() {
SB_CHECK(N_btchip.bkp.config.operationMode);
if ((SB_GET(N_btchip.bkp.config.operationMode) ==
BTCHIP_MODE_SETUP_NEEDED) ||
(SB_GET(N_btchip.bkp.config.operationMode) == BTCHIP_MODE_ISSUER)) {
return BTCHIP_SW_CONDITIONS_OF_USE_NOT_SATISFIED;
}
switch (G_io_apdu_buffer[ISO_OFFSET_P1]) {
case P1_GET_OPERATION_MODE:
G_io_apdu_buffer[0] = SB_GET(N_btchip.bkp.config.operationMode);
break;
default:
return BTCHIP_SW_INCORRECT_P1_P2;
}
btchip_context_D.outLength = 1;
return BTCHIP_SW_OK;
}

View File

@ -0,0 +1,38 @@
/*******************************************************************************
* Ledger Blue - Bitcoin Wallet
* (c) 2016 Ledger
*
* 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.
********************************************************************************/
#include "btchip_internal.h"
#include "btchip_apdu_constants.h"
#define MAX_LENGTH 248
unsigned short btchip_apdu_get_random() {
unsigned char length = G_io_apdu_buffer[ISO_OFFSET_LC];
if (length == 0) {
length = MAX_LENGTH;
}
if (length > MAX_LENGTH) {
return BTCHIP_SW_INCORRECT_LENGTH;
}
cx_rng(G_io_apdu_buffer, length);
btchip_context_D.outLength = length;
return BTCHIP_SW_OK;
}

View File

@ -0,0 +1,100 @@
/*******************************************************************************
* Ledger Blue - Bitcoin Wallet
* (c) 2016 Ledger
*
* 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.
********************************************************************************/
#include "btchip_internal.h"
#include "btchip_apdu_constants.h"
#define GET_TRUSTED_INPUT_P1_FIRST 0x00
#define GET_TRUSTED_INPUT_P1_NEXT 0x80
#define TRUSTEDINPUT_SIZE 48
unsigned short btchip_apdu_get_trusted_input() {
unsigned char apduLength;
unsigned char dataOffset = 0;
cx_sha256_t hash;
apduLength = G_io_apdu_buffer[ISO_OFFSET_LC];
SB_CHECK(N_btchip.bkp.config.operationMode);
switch (SB_GET(N_btchip.bkp.config.operationMode)) {
case BTCHIP_MODE_WALLET:
case BTCHIP_MODE_RELAXED_WALLET:
case BTCHIP_MODE_SERVER:
break;
default:
return BTCHIP_SW_CONDITIONS_OF_USE_NOT_SATISFIED;
}
if (G_io_apdu_buffer[ISO_OFFSET_P1] == GET_TRUSTED_INPUT_P1_FIRST) {
// Initialize
btchip_context_D.transactionTargetInput =
btchip_read_u32(G_io_apdu_buffer + ISO_OFFSET_CDATA, 1, 0);
btchip_context_D.transactionContext.transactionState =
BTCHIP_TRANSACTION_NONE;
btchip_context_D.trustedInputProcessed = 0;
btchip_context_D.transactionContext.consumeP2SH = 0;
btchip_set_check_internal_structure_integrity(1);
dataOffset = 4;
btchip_context_D.transactionHashOption = TRANSACTION_HASH_FULL;
} else if (G_io_apdu_buffer[ISO_OFFSET_P1] != GET_TRUSTED_INPUT_P1_NEXT) {
return BTCHIP_SW_INCORRECT_P1_P2;
}
if (G_io_apdu_buffer[ISO_OFFSET_P2] != 0x00) {
return BTCHIP_SW_INCORRECT_P1_P2;
}
btchip_context_D.transactionBufferPointer =
G_io_apdu_buffer + ISO_OFFSET_CDATA + dataOffset;
btchip_context_D.transactionDataRemaining = apduLength - dataOffset;
transaction_parse(PARSE_MODE_TRUSTED_INPUT);
if (btchip_context_D.transactionContext.transactionState ==
BTCHIP_TRANSACTION_PARSED) {
unsigned char targetHash[32];
btchip_context_D.transactionContext.transactionState =
BTCHIP_TRANSACTION_NONE;
btchip_set_check_internal_structure_integrity(1);
if (!btchip_context_D.trustedInputProcessed) {
// Output was not found
return BTCHIP_SW_INCORRECT_DATA;
}
cx_hash(&btchip_context_D.transactionHashFull.header, CX_LAST,
(unsigned char WIDE *)NULL, 0, targetHash);
// Otherwise prepare
cx_rng(G_io_apdu_buffer, 8);
G_io_apdu_buffer[0] = MAGIC_TRUSTED_INPUT;
G_io_apdu_buffer[1] = 0x00;
cx_sha256_init(&hash);
cx_hash(&hash.header, CX_LAST, targetHash, 32, G_io_apdu_buffer + 4);
btchip_write_u32_le(G_io_apdu_buffer + 4 + 32,
btchip_context_D.transactionTargetInput);
os_memmove(G_io_apdu_buffer + 4 + 32 + 4,
btchip_context_D.transactionContext.transactionAmount, 8);
cx_des((cx_des_key_t *)&N_btchip.bkp.trustedinput_key,
CX_LAST | CX_PAD_NONE | CX_SIGN | CX_CHAIN_CBC, G_io_apdu_buffer,
TRUSTEDINPUT_SIZE, G_io_apdu_buffer + TRUSTEDINPUT_SIZE);
btchip_context_D.outLength = 0x38;
}
return BTCHIP_SW_OK;
}

View File

@ -0,0 +1,86 @@
/*******************************************************************************
* Ledger Blue - Bitcoin Wallet
* (c) 2016 Ledger
*
* 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.
********************************************************************************/
#include "btchip_internal.h"
#include "btchip_apdu_constants.h"
unsigned short btchip_apdu_get_wallet_public_key() {
unsigned char keyLength;
unsigned char uncompressedPublicKeys =
((N_btchip.bkp.config.options & BTCHIP_OPTION_UNCOMPRESSED_KEYS) != 0);
unsigned char keyPath[MAX_BIP32_PATH_LENGTH];
unsigned char chainCode[32];
if ((G_io_apdu_buffer[ISO_OFFSET_P1] != 0x00) ||
(G_io_apdu_buffer[ISO_OFFSET_P2] != 0x00)) {
return BTCHIP_SW_INCORRECT_P1_P2;
}
if (G_io_apdu_buffer[ISO_OFFSET_LC] < 0x01) {
return BTCHIP_SW_INCORRECT_LENGTH;
}
os_memmove(keyPath, G_io_apdu_buffer + ISO_OFFSET_CDATA,
MAX_BIP32_PATH_LENGTH);
SB_CHECK(N_btchip.bkp.config.operationMode);
switch (SB_GET(N_btchip.bkp.config.operationMode)) {
case BTCHIP_MODE_WALLET:
case BTCHIP_MODE_RELAXED_WALLET:
case BTCHIP_MODE_SERVER:
break;
default:
return BTCHIP_SW_CONDITIONS_OF_USE_NOT_SATISFIED;
}
if (!os_global_pin_is_validated()) {
return BTCHIP_SW_SECURITY_STATUS_NOT_SATISFIED;
}
btchip_private_derive_keypair(keyPath, 1, chainCode);
G_io_apdu_buffer[0] = 65;
// Then encode it
if (uncompressedPublicKeys) {
keyLength = 65;
} else {
btchip_compress_public_key_value(btchip_public_key_D.W);
keyLength = 33;
}
os_memmove(G_io_apdu_buffer + 1, btchip_public_key_D.W,
sizeof(btchip_public_key_D.W));
keyLength = btchip_public_key_to_encoded_base58(
G_io_apdu_buffer + 1, // IN
keyLength, // INLEN
G_io_apdu_buffer + 67, // OUT
150, // MAXOUTLEN
btchip_context_D.payToAddressVersion, 0);
G_io_apdu_buffer[66] = keyLength;
L_DEBUG_APP(("Length %d\n", keyLength));
if (!uncompressedPublicKeys) {
// Restore for the full key component
G_io_apdu_buffer[1] = 0x04;
}
// output chain code
os_memmove(G_io_apdu_buffer + 1 + 65 + 1 + keyLength, chainCode,
sizeof(chainCode));
btchip_context_D.outLength = 1 + 65 + 1 + keyLength + sizeof(chainCode);
return BTCHIP_SW_OK;
}

View File

@ -0,0 +1,501 @@
/*******************************************************************************
* Ledger Blue - Bitcoin Wallet
* (c) 2016 Ledger
*
* 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.
********************************************************************************/
// TODO Trustlet, BAGL : process each output separately.
// review nvm_write policy
#include "btchip_internal.h"
#include "btchip_apdu_constants.h"
#include "btchip_bagl_extensions.h"
#define FINALIZE_P1_MORE 0x00
#define FINALIZE_P1_LAST 0x80
#define FINALIZE_P1_CHANGEINFO 0xFF
#define FLAG_SIGNATURE 0x01
#define FLAG_CHANGE_VALIDATED 0x80
unsigned short btchip_apdu_hash_input_finalize_full() {
unsigned char authorizationHash[32];
unsigned char apduLength;
unsigned short sw = BTCHIP_SW_OK;
unsigned char *target = G_io_apdu_buffer;
btchip_transaction_summary_t transactionSummary;
unsigned char keycardActivated = 0;
unsigned char screenPaired = 0;
unsigned char deepControl = 0;
unsigned char p1 = G_io_apdu_buffer[ISO_OFFSET_P1];
unsigned char p2 = G_io_apdu_buffer[ISO_OFFSET_P2];
unsigned char persistentCommit = 0;
unsigned char hashOffset = 0;
unsigned char numOutputs = 0;
SB_CHECK(N_btchip.bkp.config.operationMode);
switch (SB_GET(N_btchip.bkp.config.operationMode)) {
case BTCHIP_MODE_WALLET:
break;
case BTCHIP_MODE_RELAXED_WALLET:
persistentCommit = 1;
break;
case BTCHIP_MODE_SERVER:
break;
default:
return BTCHIP_SW_CONDITIONS_OF_USE_NOT_SATISFIED;
}
/*
if (G_io_apdu_buffer[ISO_OFFSET_P2] != 0) {
return BTCHIP_SW_INCORRECT_P1_P2;
}
*/
apduLength = G_io_apdu_buffer[ISO_OFFSET_LC];
if ((p1 != FINALIZE_P1_MORE) && (p1 != FINALIZE_P1_LAST) &&
(p1 != FINALIZE_P1_CHANGEINFO)) {
return BTCHIP_SW_INCORRECT_P1_P2;
}
// See if there is a hashing offset
if (btchip_context_D.usingSegwit &&
(btchip_context_D.tmpCtx.output.multipleOutput == 0)) {
unsigned char firstByte = G_io_apdu_buffer[ISO_OFFSET_CDATA];
if (firstByte < 0xfd) {
hashOffset = 1;
} else if (firstByte == 0xfd) {
hashOffset = 3;
} else if (firstByte == 0xfe) {
hashOffset = 5;
}
}
// Check state
BEGIN_TRY {
TRY {
btchip_set_check_internal_structure_integrity(0);
if (btchip_context_D.transactionContext.transactionState !=
BTCHIP_TRANSACTION_PRESIGN_READY) {
sw = BTCHIP_SW_CONDITIONS_OF_USE_NOT_SATISFIED;
goto discardTransaction;
}
if (p1 == FINALIZE_P1_CHANGEINFO) {
unsigned char keyLength;
if (!btchip_context_D.transactionContext.firstSigned) {
// Already validated, should be prevented on the client side
return BTCHIP_SW_OK;
}
if (!btchip_context_D.tmpCtx.output.changeAccepted) {
sw = BTCHIP_SW_CONDITIONS_OF_USE_NOT_SATISFIED;
goto discardTransaction;
}
os_memset(&transactionSummary, 0, sizeof(transactionSummary));
if (G_io_apdu_buffer[ISO_OFFSET_CDATA] == 0x00) {
// Called with no change path, abort, should be prevented on
// the client side
return BTCHIP_SW_OK;
}
os_memmove(transactionSummary.summarydata.keyPath,
G_io_apdu_buffer + ISO_OFFSET_CDATA,
MAX_BIP32_PATH_LENGTH);
btchip_private_derive_keypair(
transactionSummary.summarydata.keyPath, 1, NULL);
if (((N_btchip.bkp.config.options &
BTCHIP_OPTION_UNCOMPRESSED_KEYS) != 0)) {
keyLength = 65;
} else {
btchip_compress_public_key_value(btchip_public_key_D.W);
keyLength = 33;
}
btchip_public_key_hash160(
btchip_public_key_D.W, // IN
keyLength, // INLEN
transactionSummary.summarydata.changeAddress + 1 // OUT
);
// Commit to persistent memory if necessary
if (persistentCommit) {
os_memmove(&btchip_context_D.transactionSummary,
&transactionSummary, sizeof(transactionSummary));
}
os_memmove(
btchip_context_D.tmpCtx.output.changeAddress,
transactionSummary.summarydata.changeAddress,
sizeof(transactionSummary.summarydata.changeAddress));
btchip_context_D.tmpCtx.output.changeInitialized = 1;
btchip_context_D.tmpCtx.output.changeAccepted = 0;
return BTCHIP_SW_OK;
}
// Always update the transaction & authorization hashes with the
// given data
// For SegWit, this has been reset to hold hashOutputs
if (!btchip_context_D.segwitParsedOnce) {
cx_hash(&btchip_context_D.transactionHashFull.header, 0,
G_io_apdu_buffer + ISO_OFFSET_CDATA + hashOffset,
apduLength - hashOffset, NULL);
}
if (screenPaired) {
btchip_context_D.tmpCtx.output.outputCrc = cx_crc16_update(
btchip_context_D.tmpCtx.output.outputCrc,
G_io_apdu_buffer + ISO_OFFSET_CDATA, apduLength);
}
if ((btchip_context_D.currentOutputOffset + apduLength) >
sizeof(btchip_context_D.currentOutput)) {
L_DEBUG_APP(("Output is too long to be checked\n"));
sw = BTCHIP_SW_INCORRECT_DATA;
goto discardTransaction;
}
os_memmove(btchip_context_D.currentOutput +
btchip_context_D.currentOutputOffset,
G_io_apdu_buffer + ISO_OFFSET_CDATA, apduLength);
btchip_context_D.currentOutputOffset += apduLength;
if (G_io_apdu_buffer[ISO_OFFSET_P1] == FINALIZE_P1_MORE) {
if (!btchip_context_D.usingSegwit) {
cx_hash(
&btchip_context_D.transactionHashAuthorization.header,
0, G_io_apdu_buffer + ISO_OFFSET_CDATA, apduLength,
NULL);
}
if (screenPaired) {
} else {
G_io_apdu_buffer[0] = 0x00;
btchip_context_D.outLength = 1;
}
btchip_context_D.tmpCtx.output.multipleOutput = 1;
return BTCHIP_SW_OK;
}
if (!btchip_context_D.usingSegwit) {
cx_hash(&btchip_context_D.transactionHashAuthorization.header,
CX_LAST, G_io_apdu_buffer + ISO_OFFSET_CDATA,
apduLength, authorizationHash);
}
if (btchip_context_D.usingSegwit) {
if (!btchip_context_D.segwitParsedOnce) {
cx_hash(&btchip_context_D.transactionHashFull.header,
CX_LAST,
btchip_context_D.segwit.cache.hashedOutputs, 0,
btchip_context_D.segwit.cache.hashedOutputs);
cx_sha256_init(&btchip_context_D.transactionHashFull);
cx_hash(&btchip_context_D.transactionHashFull.header,
CX_LAST,
btchip_context_D.segwit.cache.hashedOutputs,
sizeof(btchip_context_D.segwit.cache.hashedOutputs),
btchip_context_D.segwit.cache.hashedOutputs);
L_DEBUG_BUF(("hashOutputs\n",
btchip_context_D.segwit.cache.hashedOutputs,
32));
cx_hash(
&btchip_context_D.transactionHashAuthorization.header,
CX_LAST, G_io_apdu_buffer, 0, authorizationHash);
} else {
cx_hash(
&btchip_context_D.transactionHashAuthorization.header,
CX_LAST,
(unsigned char WIDE *)&btchip_context_D.segwit.cache,
sizeof(btchip_context_D.segwit.cache),
authorizationHash);
}
}
// On last output, generate the persistent transaction context if
// necessary
/*
if (btchip_context_D.transactionContext.firstSigned) {
os_memset(&transactionSummary, 0, sizeof(transactionSummary));
transactionSummary.summarydata.relaxed =
btchip_context_D.transactionContext.relaxed;
}
*/
/* seem a dup ?!
if (G_io_apdu_buffer[ISO_OFFSET_P1] == FINALIZE_P1_LAST) {
// On last output, generate the persistent transaction context if
necessary
if (btchip_context_D.transactionContext.firstSigned) {
os_memset(&transactionSummary, 0, sizeof(transactionSummary));
transactionSummary.summarydata.relaxed =
btchip_context_D.transactionContext.relaxed;
}
}
*/
if (btchip_context_D.transactionContext.firstSigned) {
if (btchip_context_D.tmpCtx.output.changeInitialized) {
os_memmove(&transactionSummary,
&btchip_context_D.transactionSummary,
sizeof(transactionSummary));
} else {
os_memset(&transactionSummary, 0,
sizeof(transactionSummary));
}
transactionSummary.payToAddressVersion =
btchip_context_D.payToAddressVersion;
transactionSummary.payToScriptHashVersion =
btchip_context_D.payToScriptHashVersion;
if (!deepControl &&
!(screenPaired &&
!btchip_context_D.tmpCtx.output.multipleOutput)) {
transactionSummary.summarydata.relaxed = 1;
} else {
unsigned char offset = ISO_OFFSET_CDATA;
unsigned char i;
unsigned char changeFilled = 0;
unsigned char regularFilled = 0;
numOutputs = G_io_apdu_buffer[offset++];
// Too many outputs, deny
if (numOutputs > 3) {
L_DEBUG_APP(("Too many outputs\n"));
goto failControl;
}
for (i = 0; i < numOutputs; i++) {
unsigned char tmpVersion;
unsigned char address[20];
unsigned char *destinationAddress = NULL;
unsigned char *destinationAmount = NULL;
offset += 8;
if (btchip_output_script_is_regular(G_io_apdu_buffer +
offset)) {
tmpVersion = transactionSummary.payToAddressVersion;
os_memmove(address,
G_io_apdu_buffer + offset +
OUTPUT_SCRIPT_REGULAR_PRE_LENGTH,
20);
L_DEBUG_BUF(
("Regular script, address\n", address, 20));
} else if (btchip_output_script_is_p2sh(
G_io_apdu_buffer + offset)) {
tmpVersion =
transactionSummary.payToScriptHashVersion;
os_memmove(address,
G_io_apdu_buffer + offset +
OUTPUT_SCRIPT_P2SH_PRE_LENGTH,
20);
L_DEBUG_BUF(
("P2SH script, address\n", address, 20));
} else if (btchip_output_script_is_op_return(
G_io_apdu_buffer + offset)) {
unsigned char j;
for (j = 0; j < 8; j++) {
if (G_io_apdu_buffer[offset - 8 + j]) {
L_DEBUG_APP(
("Output amount is not null\n"));
goto failControl;
}
}
goto nextOutput;
} else {
L_DEBUG_APP(("Unrecognized output script\n"));
goto failControl;
}
// If the address matches the registred change, use it
if (btchip_context_D.tmpCtx.output.changeInitialized) {
if (os_memcmp(address,
btchip_context_D.tmpCtx.output
.changeAddress +
1,
20) == 0) {
if (changeFilled) {
L_DEBUG_APP(("Change already filled\n"));
goto failControl;
}
destinationAddress =
transactionSummary.summarydata
.changeAddress;
destinationAmount =
transactionSummary.summarydata.changeAmount;
btchip_context_D.tmpCtx.output.changeChecked =
1;
changeFilled = 1;
}
}
if (destinationAddress == NULL) {
if (changeFilled && regularFilled) {
L_DEBUG_APP(
("Both output addresses already filled\n"));
goto failControl;
}
if (!regularFilled) {
destinationAddress =
transactionSummary.summarydata
.outputAddress;
destinationAmount =
transactionSummary.summarydata.outputAmount;
regularFilled = 1;
} else {
destinationAddress =
transactionSummary.summarydata
.changeAddress;
destinationAmount =
transactionSummary.summarydata.changeAmount;
changeFilled = 1;
}
}
os_memmove(destinationAddress + 1, address, 20);
destinationAddress[0] = tmpVersion;
btchip_swap_bytes(destinationAmount,
G_io_apdu_buffer + offset - 8, 8);
// Otherwise fit the next input
// Then move to the next input
nextOutput:
offset += G_io_apdu_buffer[offset] + 1;
}
goto endControl;
failControl:
if (deepControl) {
sw = BTCHIP_SW_INCORRECT_DATA;
goto discardTransaction;
} else {
// Soft fail, clear validation since it is meaningless
btchip_context_D.tmpCtx.output.changeChecked = 0;
}
endControl:
// Internal change is mandatory but wasn't used, deny if it
// cannot be validated
// (keycard mode without screen cannot verify it)
if (deepControl && changeFilled &&
!btchip_context_D.tmpCtx.output.changeChecked) {
if (((N_btchip.bkp.config.options &
BTCHIP_OPTION_ALLOW_ARBITRARY_CHANGE) == 0) ||
(keycardActivated && !screenPaired)) {
L_DEBUG_APP(
("Mandatory change control not done\n"));
sw = BTCHIP_SW_INCORRECT_DATA;
goto discardTransaction;
} else {
transactionSummary.summarydata.arbitraryChange = 1;
}
}
}
if (deepControl) {
unsigned char workAmount[8];
L_DEBUG_BUF(("Output Amount\n",
transactionSummary.summarydata.outputAmount,
8));
L_DEBUG_BUF(("Change Amount\n",
transactionSummary.summarydata.changeAmount,
8));
L_DEBUG_BUF(
("Transaction Amount\n",
btchip_context_D.transactionContext.transactionAmount,
8));
if (transaction_amount_add_be(
workAmount,
transactionSummary.summarydata.outputAmount,
transactionSummary.summarydata.changeAmount) ||
transaction_amount_sub_be(
transactionSummary.summarydata.fees,
btchip_context_D.transactionContext
.transactionAmount,
workAmount)) {
L_DEBUG_APP(("Failed computing fees\n"));
sw = BTCHIP_SW_INCORRECT_DATA;
goto discardTransaction;
}
} else {
// Only used for relaxed mode
os_memmove(
transactionSummary.summarydata.outputAmount,
btchip_context_D.transactionContext.transactionAmount,
8);
}
// Generate new nonce
cx_rng(transactionSummary.summarydata.transactionNonce, 8);
transactionSummary.active =
!btchip_context_D.transactionContext.consumeP2SH &&
!keycardActivated;
} else {
os_memmove(&transactionSummary,
&btchip_context_D.transactionSummary,
sizeof(transactionSummary));
}
if (screenPaired) {
} else {
G_io_apdu_buffer[0] = 0x00;
target++;
}
*target = 0x00;
target++;
// Check that the input being signed is part of the same
// transaction, otherwise abort
// (this is done to keep the transaction counter limit per session
// synchronized)
if (btchip_context_D.transactionContext.firstSigned) {
os_memmove(transactionSummary.authorizationHash,
authorizationHash,
sizeof(transactionSummary.authorizationHash));
btchip_context_D.transactionContext.firstSigned = 0;
if (!btchip_bagl_confirm_full_output(p2)) {
sw = BTCHIP_SW_CONDITIONS_OF_USE_NOT_SATISFIED;
goto discardTransaction;
}
// TODO : review policy for persistent commit
os_memmove(&btchip_context_D.transactionSummary,
&transactionSummary, sizeof(transactionSummary));
} else {
if (btchip_secure_memcmp(
authorizationHash, transactionSummary.authorizationHash,
sizeof(transactionSummary.authorizationHash))) {
L_DEBUG_APP(
("Authorization hash not matching, aborting\n"));
sw = BTCHIP_SW_CONDITIONS_OF_USE_NOT_SATISFIED;
goto discardTransaction;
}
}
if (btchip_context_D.usingSegwit &&
!btchip_context_D.segwitParsedOnce) {
// This input cannot be signed when using segwit - just restart.
btchip_context_D.segwitParsedOnce = 1;
L_DEBUG_APP(("Segwit parsed once\n"));
btchip_context_D.transactionContext.transactionState =
BTCHIP_TRANSACTION_NONE;
} else {
btchip_context_D.transactionContext.transactionState =
BTCHIP_TRANSACTION_SIGN_READY;
}
btchip_context_D.outLength = (target - G_io_apdu_buffer);
sw = BTCHIP_SW_OK;
}
CATCH_ALL {
sw = SW_TECHNICAL_DETAILS(0x0F);
discardTransaction:
btchip_context_D.transactionContext.transactionState =
BTCHIP_TRANSACTION_NONE;
}
FINALLY {
btchip_context_D.currentOutputOffset = 0;
btchip_set_check_internal_structure_integrity(1);
return sw;
}
}
END_TRY;
}

View File

@ -0,0 +1,86 @@
/*******************************************************************************
* Ledger Blue - Bitcoin Wallet
* (c) 2016 Ledger
*
* 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.
********************************************************************************/
#include "btchip_internal.h"
#include "btchip_apdu_constants.h"
#define P1_FIRST 0x00
#define P1_NEXT 0x80
#define P2_NEW 0x00
#define P2_NEW_SEGWIT 0x02
#define P2_CONTINUE 0x80
unsigned short btchip_apdu_hash_input_start() {
unsigned char apduLength;
apduLength = G_io_apdu_buffer[ISO_OFFSET_LC];
SB_CHECK(N_btchip.bkp.config.operationMode);
switch (SB_GET(N_btchip.bkp.config.operationMode)) {
case BTCHIP_MODE_WALLET:
case BTCHIP_MODE_RELAXED_WALLET:
case BTCHIP_MODE_SERVER:
break;
default:
return BTCHIP_SW_CONDITIONS_OF_USE_NOT_SATISFIED;
}
if (G_io_apdu_buffer[ISO_OFFSET_P1] == P1_FIRST) {
// Initialize
btchip_context_D.transactionContext.transactionState =
BTCHIP_TRANSACTION_NONE;
btchip_set_check_internal_structure_integrity(1);
btchip_context_D.transactionHashOption = TRANSACTION_HASH_BOTH;
} else if (G_io_apdu_buffer[ISO_OFFSET_P1] != P1_NEXT) {
return BTCHIP_SW_INCORRECT_P1_P2;
}
if ((G_io_apdu_buffer[ISO_OFFSET_P2] == P2_NEW) ||
(G_io_apdu_buffer[ISO_OFFSET_P2] == P2_NEW_SEGWIT)) {
// btchip_context_D.transactionContext.consumeP2SH =
// ((N_btchip.bkp.config.options & BTCHIP_OPTION_SKIP_2FA_P2SH) != 0);
if (G_io_apdu_buffer[ISO_OFFSET_P1] == P1_FIRST) {
unsigned char usingSegwit =
(G_io_apdu_buffer[ISO_OFFSET_P2] == P2_NEW_SEGWIT);
// Request PIN validation
if (!os_global_pin_is_validated()) {
return BTCHIP_SW_SECURITY_STATUS_NOT_SATISFIED;
}
// Master transaction reset
btchip_context_D.transactionContext.firstSigned = 1;
btchip_context_D.transactionContext.consumeP2SH = 0;
btchip_context_D.transactionContext.relaxed = 0;
btchip_context_D.usingSegwit = usingSegwit;
btchip_context_D.segwitParsedOnce = 0;
btchip_set_check_internal_structure_integrity(1);
// Initialize for screen pairing
os_memset(&btchip_context_D.tmpCtx.output, 0,
sizeof(btchip_context_D.tmpCtx.output));
btchip_context_D.tmpCtx.output.changeAccepted = 1;
btchip_context_D.tmpCtx.output.outputCrc = CX_CRC16_INIT;
}
} else if (G_io_apdu_buffer[ISO_OFFSET_P2] != P2_CONTINUE) {
return BTCHIP_SW_INCORRECT_P1_P2;
}
btchip_context_D.transactionBufferPointer =
G_io_apdu_buffer + ISO_OFFSET_CDATA;
btchip_context_D.transactionDataRemaining = apduLength;
transaction_parse(PARSE_MODE_SIGNATURE);
return BTCHIP_SW_OK;
}

148
src/btchip_apdu_hash_sign.c Normal file
View File

@ -0,0 +1,148 @@
/*******************************************************************************
* Ledger Blue - Bitcoin Wallet
* (c) 2016 Ledger
*
* 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.
********************************************************************************/
#include "btchip_internal.h"
#include "btchip_apdu_constants.h"
#define SIGHASH_ALL 0x01
unsigned short btchip_apdu_hash_sign() {
unsigned long int lockTime;
unsigned char sighashType;
unsigned char dataBuffer[8];
unsigned char hash1[32];
unsigned char hash2[32];
unsigned char authorizationLength;
unsigned char *parameters = G_io_apdu_buffer + ISO_OFFSET_CDATA;
btchip_transaction_summary_t
transactionSummary; // could be removed with a refactor
unsigned char *authorization;
unsigned short sw;
unsigned char keyPath[MAX_BIP32_PATH_LENGTH];
cx_sha256_t localHash;
SB_CHECK(N_btchip.bkp.config.operationMode);
switch (SB_GET(N_btchip.bkp.config.operationMode)) {
case BTCHIP_MODE_WALLET:
case BTCHIP_MODE_RELAXED_WALLET:
case BTCHIP_MODE_SERVER:
break;
default:
return BTCHIP_SW_CONDITIONS_OF_USE_NOT_SATISFIED;
}
if ((G_io_apdu_buffer[ISO_OFFSET_P1] != 0) &&
(G_io_apdu_buffer[ISO_OFFSET_P2] != 0)) {
return BTCHIP_SW_INCORRECT_P1_P2;
}
if (G_io_apdu_buffer[ISO_OFFSET_LC] < (1 + 1 + 4 + 1)) {
return BTCHIP_SW_INCORRECT_LENGTH;
}
// Check state
BEGIN_TRY {
TRY {
btchip_set_check_internal_structure_integrity(0);
if (btchip_context_D.transactionContext.transactionState !=
BTCHIP_TRANSACTION_SIGN_READY) {
L_DEBUG_APP(
("Invalid transaction state %d\n",
btchip_context_D.transactionContext.transactionState));
sw = BTCHIP_SW_CONDITIONS_OF_USE_NOT_SATISFIED;
goto discardTransaction;
}
// Read parameters
if (G_io_apdu_buffer[ISO_OFFSET_CDATA] > MAX_BIP32_PATH) {
sw = BTCHIP_SW_INCORRECT_DATA;
goto discardTransaction;
}
os_memmove(keyPath, G_io_apdu_buffer + ISO_OFFSET_CDATA,
MAX_BIP32_PATH_LENGTH);
parameters += (4 * G_io_apdu_buffer[ISO_OFFSET_CDATA]) + 1;
authorizationLength = *(parameters++);
authorization = parameters;
parameters += authorizationLength;
lockTime = btchip_read_u32(parameters, 1, 0);
parameters += 4;
sighashType = *(parameters++);
if (((N_btchip.bkp.config.options &
BTCHIP_OPTION_FREE_SIGHASHTYPE) == 0)) {
if (sighashType != SIGHASH_ALL) {
sw = BTCHIP_SW_INCORRECT_DATA;
goto discardTransaction;
}
}
// Read transaction parameters
// TODO : remove copy
os_memmove(&transactionSummary,
&btchip_context_D.transactionSummary,
sizeof(transactionSummary));
// Fetch the private key
btchip_private_derive_keypair(keyPath, 0, NULL);
// TODO optional : check the public key against the associated non
// blank input to sign
// Finalize the hash
btchip_write_u32_le(dataBuffer, lockTime);
btchip_write_u32_le(dataBuffer + 4, sighashType);
L_DEBUG_BUF(
("Finalize hash with\n", dataBuffer, sizeof(dataBuffer)));
cx_hash(&btchip_context_D.transactionHashFull.header, CX_LAST,
dataBuffer, sizeof(dataBuffer), hash1);
L_DEBUG_BUF(("Hash1\n", hash1, sizeof(hash1)));
// Rehash
cx_sha256_init(&localHash);
cx_hash(&localHash.header, CX_LAST, hash1, sizeof(hash1), hash2);
L_DEBUG_BUF(("Hash2\n", hash2, sizeof(hash2)));
// Sign
btchip_signverify_finalhash(
&btchip_private_key_D, 1, hash2, sizeof(hash2),
G_io_apdu_buffer, sizeof(G_io_apdu_buffer),
((N_btchip.bkp.config.options &
BTCHIP_OPTION_DETERMINISTIC_SIGNATURE) != 0));
btchip_context_D.outLength = G_io_apdu_buffer[1] + 2;
G_io_apdu_buffer[btchip_context_D.outLength++] = sighashType;
sw = BTCHIP_SW_OK;
// Then discard the transaction and reply
}
CATCH_ALL {
sw = SW_TECHNICAL_DETAILS(0xF);
discardTransaction:
btchip_context_D.transactionContext.transactionState =
BTCHIP_TRANSACTION_NONE;
}
FINALLY {
btchip_set_check_internal_structure_integrity(1);
return sw;
}
}
END_TRY;
}

View File

@ -0,0 +1,42 @@
/*******************************************************************************
* Ledger Blue - Bitcoin Wallet
* (c) 2016 Ledger
*
* 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.
********************************************************************************/
#include "btchip_internal.h"
#include "btchip_apdu_constants.h"
unsigned short btchip_apdu_set_alternate_coin_version() {
if (G_io_apdu_buffer[ISO_OFFSET_LC] != 0x02) {
return BTCHIP_SW_INCORRECT_LENGTH;
}
SB_CHECK(N_btchip.bkp.config.operationMode);
if ((SB_GET(N_btchip.bkp.config.operationMode) ==
BTCHIP_MODE_SETUP_NEEDED) ||
(SB_GET(N_btchip.bkp.config.operationMode) == BTCHIP_MODE_ISSUER)) {
return BTCHIP_SW_CONDITIONS_OF_USE_NOT_SATISFIED;
}
if (!os_global_pin_is_validated()) {
return BTCHIP_SW_SECURITY_STATUS_NOT_SATISFIED;
}
btchip_context_D.payToAddressVersion = G_io_apdu_buffer[ISO_OFFSET_CDATA];
btchip_context_D.payToScriptHashVersion =
G_io_apdu_buffer[ISO_OFFSET_CDATA + 1];
return BTCHIP_SW_OK;
}

View File

@ -0,0 +1,72 @@
/*******************************************************************************
* Ledger Blue - Bitcoin Wallet
* (c) 2016 Ledger
*
* 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.
********************************************************************************/
// TODO BAGL : validate operation mode change
#include "btchip_internal.h"
#include "btchip_apdu_constants.h"
#define P1_DISABLE_KEYCARD 0x00
#define P1_ENABLE_KEYCARD 0x01
#define P1_ENABLE_KEYCARD_PERMANENTLY 0x02
unsigned short btchip_apdu_set_operation_mode() {
unsigned char operationMode;
if (G_io_apdu_buffer[ISO_OFFSET_LC] != 0x01) {
return BTCHIP_SW_INCORRECT_LENGTH;
}
SB_CHECK(N_btchip.bkp.config.operationMode);
if ((SB_GET(N_btchip.bkp.config.operationMode) ==
BTCHIP_MODE_SETUP_NEEDED) ||
(SB_GET(N_btchip.bkp.config.operationMode) == BTCHIP_MODE_ISSUER)) {
return BTCHIP_SW_CONDITIONS_OF_USE_NOT_SATISFIED;
}
if (!os_global_pin_is_validated()) {
return BTCHIP_SW_SECURITY_STATUS_NOT_SATISFIED;
}
operationMode = G_io_apdu_buffer[ISO_OFFSET_CDATA];
if (operationMode == BTCHIP_MODE_WALLET) {
}
if (operationMode == SB_GET(N_btchip.bkp.config.operationMode)) {
return BTCHIP_SW_OK;
}
switch (operationMode) {
case BTCHIP_MODE_WALLET:
case BTCHIP_MODE_RELAXED_WALLET:
case BTCHIP_MODE_SERVER:
case BTCHIP_MODE_DEVELOPER:
break;
default:
return BTCHIP_SW_INCORRECT_DATA;
}
SB_CHECK(N_btchip.bkp.config.supportedModes);
if ((SB_GET(N_btchip.bkp.config.supportedModes) & operationMode) == 0) {
return BTCHIP_SW_CONDITIONS_OF_USE_NOT_SATISFIED;
}
// commit new operation
btchip_set_operation_mode(operationMode);
return BTCHIP_SW_OK;
}

48
src/btchip_apdu_setup.c Normal file
View File

@ -0,0 +1,48 @@
/*******************************************************************************
* Ledger Blue - Bitcoin Wallet
* (c) 2016 Ledger
*
* 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.
********************************************************************************/
#include "btchip_internal.h"
#include "btchip_apdu_constants.h"
unsigned short btchip_apdu_setup() {
return BTCHIP_SW_INS_NOT_SUPPORTED;
}
// Setup with WALLET mode only, deterministic signatures only
void btchip_autosetup() {
btchip_config_t config;
unsigned char i;
cx_des_key_t desKey;
unsigned char tmp[16];
os_memset(&config, 0, sizeof(btchip_config_t));
config.options |= BTCHIP_OPTION_DETERMINISTIC_SIGNATURE;
SB_SET(config.supportedModes, BTCHIP_MODE_WALLET);
SB_SET(config.operationMode, BTCHIP_MODE_WALLET);
#ifdef HAVE_DEFAULT_TESTNET
config.payToAddressVersion = 111;
config.payToScriptHashVersion = 196;
#else
config.payToAddressVersion = 0;
config.payToScriptHashVersion = 5;
#endif
nvm_write((void *)&N_btchip.bkp.config, &config, sizeof(config));
cx_rng(tmp, sizeof(tmp));
cx_des_init_key(tmp, sizeof(tmp), &desKey);
nvm_write((void *)&N_btchip.bkp.trustedinput_key, &desKey, sizeof(desKey));
i = 1;
nvm_write((void *)&N_btchip.config_valid, &i, 1);
}

View File

@ -0,0 +1,59 @@
/*******************************************************************************
* Ledger Blue - Bitcoin Wallet
* (c) 2016 Ledger
*
* 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.
********************************************************************************/
// TODO BAGL : change logic - display each part, approve, sign.
// TODO 1.0.2 : report logic
#include "btchip_internal.h"
#include "btchip_apdu_constants.h"
#define P1_PREPARE 0x00
#define P1_SIGN 0x80
//#define MAX_MESSAGE_SIZE 140
#define BITID_NONE 0
#define BITID_POWERCYCLE 1
#define BITID_MULTIPLE 2
#define SLIP_13 0x8000000D
unsigned char checkBitId(unsigned char *bip32Path) {
unsigned char i;
unsigned char bip32PathLength = bip32Path[0];
bip32Path++;
if ((bip32PathLength != 0) &&
(btchip_read_u32(bip32Path, 1, 0) == SLIP_13)) {
return BITID_MULTIPLE;
}
for (i = 0; i < bip32PathLength; i++) {
unsigned short account = btchip_read_u32(bip32Path, 1, 0);
bip32Path += 4;
if (account == BITID_DERIVE) {
return BITID_POWERCYCLE;
}
if (account == BITID_DERIVE_MULTIPLE) {
return BITID_MULTIPLE;
}
}
return BITID_NONE;
}
unsigned short btchip_apdu_sign_message() {
return BTCHIP_SW_INS_NOT_SUPPORTED;
}

View File

@ -0,0 +1,23 @@
/*******************************************************************************
* Ledger Blue - Bitcoin Wallet
* (c) 2016 Ledger
*
* 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.
********************************************************************************/
#include "btchip_internal.h"
#include "btchip_apdu_constants.h"
unsigned short btchip_apdu_verify_pin() {
return BTCHIP_SW_INS_NOT_SUPPORTED;
}

View File

@ -0,0 +1,7 @@
#ifndef __BTCHIP_BAGL_H__
#define __BTCHIP_BAGL_H__
uint8_t btchip_bagl_confirm_full_output(unsigned int outputPos);
#endif

123
src/btchip_base58.c Normal file
View File

@ -0,0 +1,123 @@
/*******************************************************************************
* Ledger Blue - Bitcoin Wallet
* (c) 2016 Ledger
*
* 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.
********************************************************************************/
#include "btchip_internal.h"
unsigned char btchip_decode_base58(unsigned char WIDE *in, unsigned char length,
unsigned char *out,
unsigned char maxoutlen) {
unsigned char tmp[164];
unsigned char buffer[164];
unsigned char i;
unsigned char j;
unsigned char startAt;
unsigned char zeroCount = 0;
if (length > sizeof(tmp)) {
THROW(INVALID_PARAMETER);
}
os_memmove(tmp, in, length);
L_DEBUG_BUF(("To decode\n", tmp, length));
for (i = 0; i < length; i++) {
if (in[i] > 128) {
THROW(EXCEPTION);
}
tmp[i] = BASE58TABLE[in[i]];
if (tmp[i] == 0xff) {
THROW(EXCEPTION);
}
}
while ((zeroCount < length) && (tmp[zeroCount] == 0)) {
++zeroCount;
}
j = length;
startAt = zeroCount;
while (startAt < length) {
unsigned short remainder = 0;
unsigned char divLoop;
for (divLoop = startAt; divLoop < length; divLoop++) {
unsigned short digit256 = (unsigned short)(tmp[divLoop] & 0xff);
unsigned short tmpDiv = remainder * 58 + digit256;
tmp[divLoop] = (unsigned char)(tmpDiv / 256);
remainder = (tmpDiv % 256);
}
if (tmp[startAt] == 0) {
++startAt;
}
buffer[--j] = (unsigned char)remainder;
}
while ((j < length) && (buffer[j] == 0)) {
++j;
}
length = length - (j - zeroCount);
if (maxoutlen < length) {
L_DEBUG_APP(("Decode overflow %d %d\n", length, maxoutlen));
THROW(EXCEPTION_OVERFLOW);
}
os_memmove(out, buffer + j - zeroCount, length);
L_DEBUG_BUF(("Decoded\n", out, length));
return length;
}
unsigned char btchip_encode_base58(unsigned char WIDE *in, unsigned char length,
unsigned char *out,
unsigned char maxoutlen) {
unsigned char tmp[164];
unsigned char buffer[164];
unsigned char j;
unsigned char startAt;
unsigned char zeroCount = 0;
if (length > sizeof(tmp)) {
THROW(INVALID_PARAMETER);
}
os_memmove(tmp, in, length);
L_DEBUG_APP(("Length to encode %d\n", length));
L_DEBUG_BUF(("To encode\n", tmp, length));
while ((zeroCount < length) && (tmp[zeroCount] == 0)) {
++zeroCount;
}
j = 2 * length;
startAt = zeroCount;
while (startAt < length) {
unsigned short remainder = 0;
unsigned char divLoop;
for (divLoop = startAt; divLoop < length; divLoop++) {
unsigned short digit256 = (unsigned short)(tmp[divLoop] & 0xff);
unsigned short tmpDiv = remainder * 256 + digit256;
tmp[divLoop] = (unsigned char)(tmpDiv / 58);
remainder = (tmpDiv % 58);
}
if (tmp[startAt] == 0) {
++startAt;
}
buffer[--j] = (unsigned char)BASE58ALPHABET[remainder];
}
while ((j < (2 * length)) && (buffer[j] == BASE58ALPHABET[0])) {
++j;
}
while (zeroCount-- > 0) {
buffer[--j] = BASE58ALPHABET[0];
}
length = 2 * length - j;
if (maxoutlen < length) {
L_DEBUG_APP(("Encode overflow %d %d\n", length, maxoutlen));
THROW(EXCEPTION_OVERFLOW);
}
os_memmove(out, (buffer + j), length);
L_DEBUG_APP(("Length encoded %d\n", length));
L_DEBUG_BUF(("Encoded\n", out, length));
return length;
}

89
src/btchip_bcd.c Normal file
View File

@ -0,0 +1,89 @@
/*******************************************************************************
* Ledger Blue - Bitcoin Wallet
* (c) 2016 Ledger
*
* 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.
********************************************************************************/
#include "btchip_internal.h"
#define SCRATCH_SIZE 21
unsigned char
btchip_convert_hex_amount_to_displayable(unsigned char WIDE *amount) {
unsigned short scratch[SCRATCH_SIZE];
unsigned char offset = 0;
unsigned char nonZero = 0;
unsigned char i;
unsigned char targetOffset = 0;
unsigned char workOffset;
unsigned char j;
unsigned char nscratch = SCRATCH_SIZE;
unsigned char smin = nscratch - 2;
for (i = 0; i < SCRATCH_SIZE; i++) {
scratch[i] = 0;
}
for (i = 0; i < 8; i++) {
for (j = 0; j < 8; j++) {
unsigned char k;
unsigned short shifted_in =
(((amount[i] & 0xff) & ((1 << (7 - j)))) != 0) ? (short)1
: (short)0;
for (k = smin; k < nscratch; k++) {
scratch[k] += ((scratch[k] >= 5) ? 3 : 0);
}
if (scratch[smin] >= 8) {
smin -= 1;
}
for (k = smin; k < nscratch - 1; k++) {
scratch[k] =
((scratch[k] << 1) & 0xF) | ((scratch[k + 1] >= 8) ? 1 : 0);
}
scratch[nscratch - 1] = ((scratch[nscratch - 1] << 1) & 0x0F) |
(shifted_in == 1 ? 1 : 0);
}
}
for (i = 0; i < 13; i++) {
if (!nonZero && (scratch[offset] == 0)) {
offset++;
} else {
nonZero = 1;
btchip_context_D.tmp[targetOffset++] = scratch[offset++] + '0';
}
}
if (targetOffset == 0) {
btchip_context_D.tmp[targetOffset++] = '0';
}
btchip_context_D.tmp[targetOffset++] = '.';
workOffset = offset;
for (i = 0; i < 8; i++) {
unsigned char allZero = 1;
unsigned char j;
for (j = i; j < 8; j++) {
if (scratch[workOffset + j] != 0) {
allZero = 0;
break;
}
}
if (allZero) {
break;
}
btchip_context_D.tmp[targetOffset++] = scratch[offset++] + '0';
}
if (targetOffset == 2) {
targetOffset--; // only 0
}
return targetOffset;
}

54
src/btchip_context.c Normal file
View File

@ -0,0 +1,54 @@
/*******************************************************************************
* Ledger Blue - Bitcoin Wallet
* (c) 2016 Ledger
*
* 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.
********************************************************************************/
#include "btchip_internal.h"
void btchip_autosetup(void);
/**
* Initialize the application context on boot
*/
void btchip_context_init() {
L_DEBUG_APP(("Context init\n"));
L_DEBUG_APP(("Backup size %d\n", sizeof(N_btchip.bkp)));
os_memset(&btchip_context_D, 0, sizeof(btchip_context_D));
SB_SET(btchip_context_D.halted, 0);
btchip_context_D.currentOutputOffset = 0;
if (N_btchip.config_valid != 0x01) {
btchip_autosetup();
}
if (!N_btchip.config_valid) {
unsigned char defaultMode;
L_DEBUG_APP(("No configuration found\n"));
defaultMode = BTCHIP_MODE_SETUP_NEEDED;
btchip_set_operation_mode(defaultMode);
} else {
btchip_context_D.payToAddressVersion =
N_btchip.bkp.config.payToAddressVersion;
btchip_context_D.payToScriptHashVersion =
N_btchip.bkp.config.payToScriptHashVersion;
SB_CHECK(N_btchip.bkp.config.operationMode);
}
if (!N_btchip.storageInitialized) {
unsigned char initialized = 1;
nvm_write((void *)&N_btchip.storageInitialized, &initialized, 1);
}
}

22
src/btchip_ecc.c Normal file
View File

@ -0,0 +1,22 @@
/*******************************************************************************
* Ledger Blue - Bitcoin Wallet
* (c) 2016 Ledger
*
* 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.
********************************************************************************/
#include "btchip_internal.h"
void btchip_compress_public_key_value(unsigned char *value) {
value[0] = ((value[64] & 1) ? 0x03 : 0x02);
}

29
src/btchip_filesystem.c Normal file
View File

@ -0,0 +1,29 @@
/*******************************************************************************
* Ledger Blue - Bitcoin Wallet
* (c) 2016 Ledger
*
* 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.
********************************************************************************/
#include "btchip_internal.h"
#include "btchip_public_ram_variables.h"
void btchip_set_operation_mode(unsigned char operationMode) {
secu8 opMode;
SB_SET(opMode, operationMode);
// only modify operation mode
nvm_write((void *)&N_btchip.bkp.config.operationMode, &opMode,
sizeof(opMode));
}

271
src/btchip_helpers.c Normal file
View File

@ -0,0 +1,271 @@
/*******************************************************************************
* Ledger Blue - Bitcoin Wallet
* (c) 2016 Ledger
*
* 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.
********************************************************************************/
#include "btchip_internal.h"
#include "btchip_apdu_constants.h"
const unsigned char TRANSACTION_OUTPUT_SCRIPT_PRE[] = {
0x19, 0x76, 0xA9,
0x14}; // script length, OP_DUP, OP_HASH160, address length
const unsigned char TRANSACTION_OUTPUT_SCRIPT_POST[] = {
0x88, 0xAC}; // OP_EQUALVERIFY, OP_CHECKSIG
const unsigned char TRANSACTION_OUTPUT_SCRIPT_P2SH_PRE[] = {
0x17, 0xA9, 0x14}; // script length, OP_HASH160, address length
const unsigned char TRANSACTION_OUTPUT_SCRIPT_P2SH_POST[] = {0x87}; // OP_EQUAL
unsigned char btchip_output_script_is_regular(unsigned char *buffer) {
if ((os_memcmp(buffer, TRANSACTION_OUTPUT_SCRIPT_PRE,
sizeof(TRANSACTION_OUTPUT_SCRIPT_PRE)) == 0) &&
(os_memcmp(buffer + sizeof(TRANSACTION_OUTPUT_SCRIPT_PRE) + 20,
TRANSACTION_OUTPUT_SCRIPT_POST,
sizeof(TRANSACTION_OUTPUT_SCRIPT_POST)) == 0)) {
return 1;
}
return 0;
}
unsigned char btchip_output_script_is_p2sh(unsigned char *buffer) {
if ((os_memcmp(buffer, TRANSACTION_OUTPUT_SCRIPT_P2SH_PRE,
sizeof(TRANSACTION_OUTPUT_SCRIPT_P2SH_PRE)) == 0) &&
(os_memcmp(buffer + sizeof(TRANSACTION_OUTPUT_SCRIPT_P2SH_PRE) + 20,
TRANSACTION_OUTPUT_SCRIPT_P2SH_POST,
sizeof(TRANSACTION_OUTPUT_SCRIPT_P2SH_POST)) == 0)) {
return 1;
}
return 0;
}
unsigned char btchip_output_script_is_op_return(unsigned char *buffer) {
return (buffer[1] == 0x6A);
}
unsigned char btchip_rng_u8_modulo(unsigned char modulo) {
unsigned int rng_max = 256 % modulo;
unsigned int rng_limit = 256 - rng_max;
unsigned char candidate;
while ((candidate = cx_rng_u8()) > rng_limit)
;
return (candidate % modulo);
}
unsigned char btchip_secure_memcmp(const void WIDE *buf1, const void WIDE *buf2,
unsigned short length) {
unsigned char error = 0;
while (length--) {
error |= ((unsigned char WIDE *)buf1)[length] ^
((unsigned char WIDE *)buf2)[length];
}
if (length != 0xffff) {
return 1;
}
return error;
}
unsigned long int btchip_read_u32(unsigned char WIDE *buffer, unsigned char be,
unsigned char skipSign) {
unsigned char i;
unsigned long int result = 0;
unsigned char shiftValue = (be ? 24 : 0);
for (i = 0; i < 4; i++) {
unsigned char x = (unsigned char)buffer[i];
if ((i == 0) && skipSign) {
x &= 0x7f;
}
result += ((unsigned long int)x) << shiftValue;
if (be) {
shiftValue -= 8;
} else {
shiftValue += 8;
}
}
return result;
}
void btchip_write_u32_be(unsigned char *buffer, unsigned long int value) {
buffer[0] = ((value >> 24) & 0xff);
buffer[1] = ((value >> 16) & 0xff);
buffer[2] = ((value >> 8) & 0xff);
buffer[3] = (value & 0xff);
}
void btchip_write_u32_le(unsigned char *buffer, unsigned long int value) {
buffer[0] = (value & 0xff);
buffer[1] = ((value >> 8) & 0xff);
buffer[2] = ((value >> 16) & 0xff);
buffer[3] = ((value >> 24) & 0xff);
}
void btchip_retrieve_keypair_discard(unsigned char WIDE *privateComponent,
unsigned char derivePublic) {
BEGIN_TRY {
TRY {
cx_ecdsa_init_private_key(BTCHIP_CURVE, privateComponent, 32,
&btchip_private_key_D);
L_DEBUG_BUF(("Using private component\n", privateComponent, 32));
if (derivePublic) {
cx_ecfp_generate_pair(BTCHIP_CURVE, &btchip_public_key_D,
&btchip_private_key_D, 1);
}
}
FINALLY {
}
}
END_TRY;
}
void btchip_public_key_hash160(unsigned char WIDE *in, unsigned short inlen,
unsigned char *out) {
union {
cx_sha256_t shasha;
cx_ripemd160_t riprip;
} u;
unsigned char buffer[32];
cx_sha256_init(&u.shasha);
cx_hash(&u.shasha.header, CX_LAST, in, inlen, buffer);
cx_ripemd160_init(&u.riprip);
cx_hash(&u.riprip.header, CX_LAST, buffer, 32, out);
}
unsigned short btchip_public_key_to_encoded_base58(
unsigned char WIDE *in, unsigned short inlen, unsigned char *out,
unsigned short outlen, unsigned char version, unsigned char alreadyHashed) {
unsigned char tmpBuffer[25];
unsigned char checksumBuffer[32];
cx_sha256_t hash;
if (!alreadyHashed) {
L_DEBUG_BUF(("To hash\n", in, inlen));
btchip_public_key_hash160(in, inlen, tmpBuffer + 1);
L_DEBUG_BUF(("Hash160\n", (tmpBuffer + 1), 20));
tmpBuffer[0] = version;
} else {
os_memmove(tmpBuffer, in, 21);
}
cx_sha256_init(&hash);
cx_hash(&hash.header, CX_LAST, tmpBuffer, 21, checksumBuffer);
cx_sha256_init(&hash);
cx_hash(&hash.header, CX_LAST, checksumBuffer, 32, checksumBuffer);
L_DEBUG_BUF(("Checksum\n", checksumBuffer, 4));
os_memmove(tmpBuffer + 21, checksumBuffer, 4);
return btchip_encode_base58(tmpBuffer, sizeof(tmpBuffer), out, outlen);
}
void btchip_swap_bytes(unsigned char *target, unsigned char *source,
unsigned char size) {
unsigned char i;
for (i = 0; i < size; i++) {
target[i] = source[size - 1 - i];
}
}
unsigned short btchip_decode_base58_address(unsigned char WIDE *in,
unsigned short inlen,
unsigned char *out,
unsigned short outlen) {
unsigned char hashBuffer[32];
cx_sha256_t hash;
outlen = btchip_decode_base58(in, inlen, out, outlen);
// Compute hash to verify address
cx_sha256_init(&hash);
cx_hash(&hash.header, CX_LAST, out, outlen - 4, hashBuffer);
cx_sha256_init(&hash);
cx_hash(&hash.header, CX_LAST, hashBuffer, 32, hashBuffer);
if (os_memcmp(out + outlen - 4, hashBuffer, 4)) {
L_DEBUG_BUF(
("Hash checksum mismatch\n", hashBuffer, sizeof(hashBuffer)));
THROW(INVALID_CHECKSUM);
}
return outlen;
}
void btchip_private_derive_keypair(unsigned char WIDE *bip32Path,
unsigned char derivePublic,
unsigned char *out_chainCode) {
unsigned char bip32PathLength;
unsigned char i;
unsigned int bip32PathInt[MAX_BIP32_PATH];
unsigned char privateComponent[32];
bip32PathLength = bip32Path[0];
if (bip32PathLength > MAX_BIP32_PATH) {
THROW(INVALID_PARAMETER);
}
bip32Path++;
for (i = 0; i < bip32PathLength; i++) {
bip32PathInt[i] = btchip_read_u32(bip32Path, 1, 0);
bip32Path += 4;
}
os_perso_derive_seed_bip32(bip32PathInt, bip32PathLength, privateComponent,
out_chainCode);
btchip_retrieve_keypair_discard(privateComponent, derivePublic);
os_memset(privateComponent, 0, sizeof(privateComponent));
}
void btchip_transaction_add_output(unsigned char *hash160Address,
unsigned char *amount, unsigned char p2sh) {
const unsigned char *pre = (p2sh ? TRANSACTION_OUTPUT_SCRIPT_P2SH_PRE
: TRANSACTION_OUTPUT_SCRIPT_PRE);
const unsigned char *post = (p2sh ? TRANSACTION_OUTPUT_SCRIPT_P2SH_POST
: TRANSACTION_OUTPUT_SCRIPT_POST);
unsigned char sizePre = (p2sh ? sizeof(TRANSACTION_OUTPUT_SCRIPT_P2SH_PRE)
: sizeof(TRANSACTION_OUTPUT_SCRIPT_PRE));
unsigned char sizePost = (p2sh ? sizeof(TRANSACTION_OUTPUT_SCRIPT_P2SH_POST)
: sizeof(TRANSACTION_OUTPUT_SCRIPT_POST));
if (amount != NULL) {
btchip_swap_bytes(btchip_context_D.tmp, amount, 8);
btchip_context_D.tmp += 8;
}
os_memmove(btchip_context_D.tmp, (void *)pre, sizePre);
btchip_context_D.tmp += sizePre;
os_memmove(btchip_context_D.tmp, hash160Address, 20);
btchip_context_D.tmp += 20;
os_memmove(btchip_context_D.tmp, (void *)post, sizePost);
btchip_context_D.tmp += sizePost;
}
unsigned char btchip_address_isP2SH(unsigned char version) {
return ((btchip_context_D.payToScriptHashVersion != 0) &&
(version == btchip_context_D.payToScriptHashVersion));
}
unsigned char btchip_address_isValid(unsigned char version) {
return ((version == btchip_context_D.payToAddressVersion) ||
btchip_address_isP2SH(version));
}
void btchip_signverify_finalhash(void WIDE *keyContext, unsigned char sign,
unsigned char WIDE *in, unsigned short inlen,
unsigned char *out, unsigned short outlen,
unsigned char rfc6979) {
if (sign) {
cx_ecdsa_sign((cx_ecfp_private_key_t WIDE *)keyContext,
CX_LAST | (rfc6979 ? CX_RND_RFC6979 : CX_RND_TRNG),
CX_SHA256, in, inlen, out);
} else {
cx_ecdsa_verify((cx_ecfp_public_key_t WIDE *)keyContext, CX_LAST,
CX_SHA256, in, inlen, out, outlen);
}
}

32
src/btchip_internal.h Normal file
View File

@ -0,0 +1,32 @@
/*******************************************************************************
* Ledger Blue - Bitcoin Wallet
* (c) 2016 Ledger
*
* 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.
********************************************************************************/
#ifndef BTCHIP_INTERNAL_H
#define BTCHIP_INTERNAL_H
#include "btchip.h"
#include "btchip_public_ram_variables.h"
#include "btchip_public_ram_key_variables.h"
#include "btchip_rom_variables.h"
#include "btchip_filesystem.h"
#include "btchip_base58.h"
#include "btchip_bcd.h"
#include "btchip_ecc.h"
#include "btchip_helpers.h"
#include "btchip_transaction.h"
#endif

22
src/btchip_nvram.c Normal file
View File

@ -0,0 +1,22 @@
/*******************************************************************************
* Ledger Blue - Bitcoin Wallet
* (c) 2016 Ledger
*
* 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.
********************************************************************************/
#include "btchip_internal.h"
#include "btchip_public_ram_variables.h"
WIDE btchip_storage_t const N_btchip;

View File

@ -0,0 +1,21 @@
/*******************************************************************************
* Ledger Blue - Bitcoin Wallet
* (c) 2016 Ledger
*
* 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.
********************************************************************************/
#include "btchip_public_ram_key_variables.h"
cx_ecfp_public_key_t btchip_public_key_D;
cx_ecfp_private_key_t btchip_private_key_D;

View File

@ -0,0 +1,30 @@
/*******************************************************************************
* Ledger Blue - Bitcoin Wallet
* (c) 2016 Ledger
*
* 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.
********************************************************************************/
#ifndef BTCHIP_PUBLIC_RAM_KEY_VARIABLES_H
#define BTCHIP_PUBLIC_RAM_KEY_VARIABLES_H
#include "btchip_config.h"
#include "btchip_secure_value.h"
#include "btchip_context.h"
extern cx_ecfp_public_key_t btchip_public_key_D;
extern cx_ecfp_private_key_t btchip_private_key_D;
#endif

View File

@ -0,0 +1,20 @@
/*******************************************************************************
* Ledger Blue - Bitcoin Wallet
* (c) 2016 Ledger
*
* 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.
********************************************************************************/
#include "btchip_public_ram_variables.h"
btchip_context_t btchip_context_D;

View File

@ -0,0 +1,29 @@
/*******************************************************************************
* Ledger Blue - Bitcoin Wallet
* (c) 2016 Ledger
*
* 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.
********************************************************************************/
#ifndef BTCHIP_PUBLIC_RAM_VARIABLES_H
#define BTCHIP_PUBLIC_RAM_VARIABLES_H
#include "btchip_config.h"
#include "btchip_secure_value.h"
#include "btchip_context.h"
extern btchip_context_t btchip_context_D;
#endif

112
src/btchip_rom_variables.c Normal file
View File

@ -0,0 +1,112 @@
/*******************************************************************************
* Ledger Blue - Bitcoin Wallet
* (c) 2016 Ledger
*
* 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.
********************************************************************************/
#include "btchip_internal.h"
#include "btchip_apdu_constants.h"
unsigned char const HEXDIGITS[] = {'0', '1', '2', '3', '4', '5', '6', '7',
'8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
unsigned char const BASE58TABLE[] = {
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf,
0x10, 0xff, 0x11, 0x12, 0x13, 0x14, 0x15, 0xff, 0x16, 0x17, 0x18, 0x19,
0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b,
0xff, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36,
0x37, 0x38, 0x39, 0xff, 0xff, 0xff, 0xff, 0xff};
unsigned char const BASE58ALPHABET[] = {
'1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F',
'G', 'H', 'J', 'K', 'L', 'M', 'N', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W',
'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'm',
'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'};
unsigned char const SIGNMAGIC[] = {0x18, 'B', 'i', 't', 'c', 'o', 'i', 'n', ' ',
'S', 'i', 'g', 'n', 'e', 'd', ' ', 'M', 'e',
's', 's', 'a', 'g', 'e', ':', '\n'};
unsigned char const TWOPOWER[] = {0x01, 0x02, 0x04, 0x08,
0x10, 0x20, 0x40, 0x80};
unsigned char const DISPATCHER_CLA[] = {
BTCHIP_CLA, // btchip_apdu_setup,
BTCHIP_CLA, // btchip_apdu_verify_pin,
BTCHIP_CLA, // btchip_apdu_get_operation_mode,
BTCHIP_CLA, // btchip_apdu_set_operation_mode,
BTCHIP_CLA, // btchip_apdu_get_wallet_public_key,
BTCHIP_CLA, // btchip_apdu_get_trusted_input,
BTCHIP_CLA, // btchip_apdu_hash_input_start,
BTCHIP_CLA, // btchip_apdu_hash_sign,
BTCHIP_CLA, // btchip_apdu_hash_input_finalize_full,
BTCHIP_CLA, // btchip_apdu_sign_message,
BTCHIP_CLA, // btchip_apdu_get_random,
BTCHIP_CLA, // btchip_apdu_get_firmware_version,
BTCHIP_CLA, // btchip_apdu_set_alternate_coin_version
};
unsigned char const DISPATCHER_INS[] = {
BTCHIP_INS_SETUP, // btchip_apdu_setup,
BTCHIP_INS_VERIFY_PIN, // btchip_apdu_verify_pin,
BTCHIP_INS_GET_OPERATION_MODE, // btchip_apdu_get_operation_mode,
BTCHIP_INS_SET_OPERATION_MODE, // btchip_apdu_set_operation_mode,
BTCHIP_INS_GET_WALLET_PUBLIC_KEY, // btchip_apdu_get_wallet_public_key,
BTCHIP_INS_GET_TRUSTED_INPUT, // btchip_apdu_get_trusted_input,
BTCHIP_INS_HASH_INPUT_START, // btchip_apdu_hash_input_start,
BTCHIP_INS_HASH_SIGN, // btchip_apdu_hash_sign,
BTCHIP_INS_HASH_INPUT_FINALIZE_FULL, // btchip_apdu_hash_input_finalize_full,
BTCHIP_INS_SIGN_MESSAGE, // btchip_apdu_sign_message,
BTCHIP_INS_GET_RANDOM, // btchip_apdu_get_random,
BTCHIP_INS_GET_FIRMWARE_VERSION, // btchip_apdu_get_firmware_version,
BTCHIP_INS_SET_ALTERNATE_COIN_VER, // btchip_apdu_set_alternate_coin_version
};
unsigned char const DISPATCHER_DATA_IN[] = {
1, // btchip_apdu_setup,
1, // btchip_apdu_verify_pin,
0, // btchip_apdu_get_operation_mode,
1, // btchip_apdu_set_operation_mode,
1, // btchip_apdu_get_wallet_public_key,
1, // btchip_apdu_get_trusted_input,
1, // btchip_apdu_hash_input_start,
1, // btchip_apdu_hash_sign,
1, // btchip_apdu_hash_input_finalize_full,
1, // btchip_apdu_sign_message,
0, // btchip_apdu_get_random,
0, // btchip_apdu_get_firmware_version,
1, // btchip_apdu_set_alternate_coin_version
};
apduProcessingFunction const DISPATCHER_FUNCTIONS[] = {
btchip_apdu_setup,
btchip_apdu_verify_pin,
btchip_apdu_get_operation_mode,
btchip_apdu_set_operation_mode,
btchip_apdu_get_wallet_public_key,
btchip_apdu_get_trusted_input,
btchip_apdu_hash_input_start,
btchip_apdu_hash_sign,
btchip_apdu_hash_input_finalize_full,
btchip_apdu_sign_message,
btchip_apdu_get_random,
btchip_apdu_get_firmware_version,
btchip_apdu_set_alternate_coin_version,
};

View File

@ -0,0 +1,63 @@
/*******************************************************************************
* Ledger Blue - Bitcoin Wallet
* (c) 2016 Ledger
*
* 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.
********************************************************************************/
#include "btchip_internal.h"
#define SIGNMAGIC_LENGTH 25
extern unsigned char const WIDE HEXDIGITS[16];
extern unsigned char const WIDE BASE58TABLE[128];
extern unsigned char const WIDE BASE58ALPHABET[58];
extern unsigned char const WIDE SIGNMAGIC[SIGNMAGIC_LENGTH];
#define HDKEY_VERSION_LENGTH 4
extern unsigned char const WIDE TWOPOWER[8];
#define APDU_DEBUG_LENGTH 0
#define APDU_NFCPAYMENT_LENGTH 0
#define APDU_BIP70_LENGTH 0
#define APDU_MOFN_LENGTH 0
#define APDU_KEYCARD_LENGTH 0
#define APDU_PORTABLE_LENGTH 5
#define APDU_KEYBOARD_LENGTH 0
#define APDU_LEGACY_SETUP_LENGTH 0
#define APDU_DEVELOPER_MODE_LENGTH 0
#define APDU_BASE_LENGTH 14
#define DISPATCHER_APDUS \
APDU_BASE_LENGTH + APDU_DEBUG_LENGTH + APDU_NFCPAYMENT_LENGTH + \
APDU_BIP70_LENGTH + APDU_MOFN_LENGTH + APDU_KEYCARD_LENGTH + \
APDU_PORTABLE_LENGTH + APDU_KEYBOARD_LENGTH + \
APDU_LEGACY_SETUP_LENGTH + APDU_DEVELOPER_MODE_LENGTH
typedef unsigned short (*WIDE apduProcessingFunction)(void);
extern unsigned char const WIDE DISPATCHER_CLA[DISPATCHER_APDUS];
extern unsigned char const WIDE DISPATCHER_INS[DISPATCHER_APDUS];
extern unsigned char const WIDE DISPATCHER_DATA_IN[DISPATCHER_APDUS];
extern apduProcessingFunction const DISPATCHER_FUNCTIONS[DISPATCHER_APDUS];

38
src/btchip_secure_value.c Normal file
View File

@ -0,0 +1,38 @@
/*******************************************************************************
* Ledger Blue - Bitcoin Wallet
* (c) 2016 Ledger
*
* 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.
********************************************************************************/
#include "btchip_internal.h"
void sbSet(secu8 *target, unsigned char source) {
*target = (((unsigned char)~source) << 8) + source;
}
void sbCheck(secu8 source) {
if (((source >> 8) & 0xff) != (unsigned char)(~(source & 0xff))) {
reset();
}
}
void ssSet(secu16 *target, unsigned short source) {
*target = (((unsigned long int)((unsigned short)~source)) << 16) + source;
}
void ssCheck(secu16 source) {
if (((source >> 16) & 0xffff) != (unsigned short)(~(source & 0xffff))) {
reset();
}
}

785
src/btchip_transaction.c Normal file
View File

@ -0,0 +1,785 @@
/*******************************************************************************
* Ledger Blue - Bitcoin Wallet
* (c) 2016 Ledger
*
* 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.
********************************************************************************/
#include "btchip_internal.h"
#include "btchip_apdu_constants.h"
#define DEBUG_LONG "%ld"
void check_transaction_available(unsigned char x) {
if (btchip_context_D.transactionDataRemaining < x) {
L_DEBUG_APP(("Check transaction available failed %d < %d\n",
btchip_context_D.transactionDataRemaining, x));
THROW(EXCEPTION);
}
}
#define OP_HASH160 0xA9
#define OP_EQUAL 0x87
#define OP_CHECKMULTISIG 0xAE
unsigned char transaction_amount_add_be(unsigned char *target,
unsigned char WIDE *a,
unsigned char WIDE *b) {
unsigned char carry = 0;
unsigned char i;
for (i = 0; i < 8; i++) {
unsigned short val = a[8 - 1 - i] + b[8 - 1 - i] + (carry ? 1 : 0);
carry = (val > 255);
target[8 - 1 - i] = (val & 255);
}
return carry;
}
unsigned char transaction_amount_sub_be(unsigned char *target,
unsigned char WIDE *a,
unsigned char WIDE *b) {
unsigned char borrow = 0;
unsigned char i;
for (i = 0; i < 8; i++) {
unsigned short tmpA = a[8 - 1 - i];
unsigned short tmpB = b[8 - 1 - i];
if (borrow) {
if (tmpA <= tmpB) {
tmpA += (255 + 1) - 1;
} else {
borrow = 0;
tmpA--;
}
}
if (tmpA < tmpB) {
borrow = 1;
tmpA += 255 + 1;
}
target[8 - 1 - i] = (unsigned char)(tmpA - tmpB);
}
return borrow;
}
void transaction_offset(unsigned char value) {
if ((btchip_context_D.transactionHashOption & TRANSACTION_HASH_FULL) != 0) {
L_DEBUG_BUF(("Add to hash full\n",
btchip_context_D.transactionBufferPointer, value));
cx_hash(&btchip_context_D.transactionHashFull.header, 0,
btchip_context_D.transactionBufferPointer, value, NULL);
}
if ((btchip_context_D.transactionHashOption &
TRANSACTION_HASH_AUTHORIZATION) != 0) {
cx_hash(&btchip_context_D.transactionHashAuthorization.header, 0,
btchip_context_D.transactionBufferPointer, value, NULL);
}
}
void transaction_offset_increase(unsigned char value) {
transaction_offset(value);
btchip_context_D.transactionBufferPointer += value;
btchip_context_D.transactionDataRemaining -= value;
}
unsigned long int transaction_get_varint(void) {
unsigned char firstByte;
check_transaction_available(1);
firstByte = *btchip_context_D.transactionBufferPointer;
if (firstByte < 0xFD) {
transaction_offset_increase(1);
return firstByte;
} else if (firstByte == 0xFD) {
unsigned long int result;
transaction_offset_increase(1);
check_transaction_available(2);
result =
(unsigned long int)(*btchip_context_D.transactionBufferPointer) |
((unsigned long int)(*(btchip_context_D.transactionBufferPointer +
1))
<< 8);
transaction_offset_increase(2);
return result;
} else if (firstByte == 0xFE) {
unsigned long int result;
transaction_offset_increase(1);
check_transaction_available(4);
result =
btchip_read_u32(btchip_context_D.transactionBufferPointer, 0, 0);
transaction_offset_increase(4);
return result;
} else {
L_DEBUG_APP(("Varint parsing failed\n"));
THROW(INVALID_PARAMETER);
return 0;
}
}
void transaction_parse(unsigned char parseMode) {
unsigned char optionP2SHSkip2FA =
((N_btchip.bkp.config.options & BTCHIP_OPTION_SKIP_2FA_P2SH) != 0);
btchip_set_check_internal_structure_integrity(0);
BEGIN_TRY {
TRY {
for (;;) {
switch (btchip_context_D.transactionContext.transactionState) {
case BTCHIP_TRANSACTION_NONE: {
L_DEBUG_APP(("Init transaction parser\n"));
// Reset transaction state
btchip_context_D.transactionContext
.transactionRemainingInputsOutputs = 0;
btchip_context_D.transactionContext
.transactionCurrentInputOutput = 0;
btchip_context_D.transactionContext.scriptRemaining = 0;
os_memset(
btchip_context_D.transactionContext.transactionAmount,
0, sizeof(btchip_context_D.transactionContext
.transactionAmount));
// TODO : transactionControlFid
// Reset hashes
cx_sha256_init(&btchip_context_D.transactionHashFull);
cx_sha256_init(
&btchip_context_D.transactionHashAuthorization);
if (btchip_context_D.usingSegwit) {
btchip_context_D.transactionHashOption = 0;
if (!btchip_context_D.segwitParsedOnce) {
cx_sha256_init(
&btchip_context_D.segwit.hash.hashPrevouts);
cx_sha256_init(
&btchip_context_D.segwit.hash.hashSequence);
} else {
L_DEBUG_APP(("Resume SegWit hash\n"));
L_DEBUG_BUF(
("SEGWIT Version\n",
btchip_context_D.transactionVersion,
sizeof(btchip_context_D.transactionVersion)));
L_DEBUG_BUF(
("SEGWIT HashedPrevouts\n",
btchip_context_D.segwit.cache.hashedPrevouts,
sizeof(btchip_context_D.segwit.cache
.hashedPrevouts)));
L_DEBUG_BUF(
("SEGWIT HashedSequence\n",
btchip_context_D.segwit.cache.hashedSequence,
sizeof(btchip_context_D.segwit.cache
.hashedSequence)));
cx_hash(
&btchip_context_D.transactionHashFull.header, 0,
btchip_context_D.transactionVersion,
sizeof(btchip_context_D.transactionVersion),
NULL);
cx_hash(
&btchip_context_D.transactionHashFull.header, 0,
btchip_context_D.segwit.cache.hashedPrevouts,
sizeof(btchip_context_D.segwit.cache
.hashedPrevouts),
NULL);
cx_hash(
&btchip_context_D.transactionHashFull.header, 0,
btchip_context_D.segwit.cache.hashedSequence,
sizeof(btchip_context_D.segwit.cache
.hashedSequence),
NULL);
cx_hash(&btchip_context_D
.transactionHashAuthorization.header,
0, (unsigned char WIDE *)&btchip_context_D
.segwit.cache,
sizeof(btchip_context_D.segwit.cache),
NULL);
}
}
// Parse the beginning of the transaction
// Version
check_transaction_available(4);
os_memmove(btchip_context_D.transactionVersion,
btchip_context_D.transactionBufferPointer, 4);
transaction_offset_increase(4);
// Number of inputs
btchip_context_D.transactionContext
.transactionRemainingInputsOutputs =
transaction_get_varint();
L_DEBUG_APP(("Number of inputs : " DEBUG_LONG "\n",
btchip_context_D.transactionContext
.transactionRemainingInputsOutputs));
// Ready to proceed
btchip_context_D.transactionContext.transactionState =
BTCHIP_TRANSACTION_DEFINED_WAIT_INPUT;
// no break is intentional
}
case BTCHIP_TRANSACTION_DEFINED_WAIT_INPUT: {
unsigned char trustedInputFlag = 1;
L_DEBUG_APP(("Process input\n"));
if (btchip_context_D.transactionContext
.transactionRemainingInputsOutputs == 0) {
// No more inputs to hash, move forward
btchip_context_D.transactionContext.transactionState =
BTCHIP_TRANSACTION_INPUT_HASHING_DONE;
continue;
}
if (btchip_context_D.transactionDataRemaining < 1) {
// No more data to read, ok
goto ok;
}
// Proceed with the next input
if (parseMode == PARSE_MODE_TRUSTED_INPUT) {
check_transaction_available(
36); // prevout : 32 hash + 4 index
transaction_offset_increase(36);
}
if (parseMode == PARSE_MODE_SIGNATURE) {
unsigned char trustedInputLength;
unsigned char trustedInput[0x38];
unsigned char amount[8];
unsigned char *savePointer;
// Expect the trusted input flag and trusted input
// length
check_transaction_available(2);
switch (*btchip_context_D.transactionBufferPointer) {
case 0:
if (btchip_context_D.usingSegwit) {
L_DEBUG_APP(
("Non trusted input used in segwit mode"));
goto fail;
}
trustedInputFlag = 0;
break;
case 1:
if (btchip_context_D.usingSegwit) {
L_DEBUG_APP(
("Trusted input used in segwit mode"));
goto fail;
}
trustedInputFlag = 1;
break;
case 2:
if (!btchip_context_D.usingSegwit) {
L_DEBUG_APP(
("Segwit input not used in segwit mode"));
goto fail;
}
break;
default:
L_DEBUG_APP(("Invalid trusted input flag\n"));
goto fail;
}
/*
trustedInputLength =
*(btchip_context_D.transactionBufferPointer + 1);
if (trustedInputLength > sizeof(trustedInput)) {
L_DEBUG_APP(("Trusted input too long\n"));
goto fail;
}
*/
if (btchip_context_D.usingSegwit) {
transaction_offset_increase(1);
check_transaction_available(
36); // prevout : 32 hash + 4 index
if (!btchip_context_D.segwitParsedOnce) {
cx_hash(
&btchip_context_D.segwit.hash.hashPrevouts
.header,
0,
btchip_context_D.transactionBufferPointer,
36, NULL);
transaction_offset_increase(36);
check_transaction_available(8); // update amount
btchip_swap_bytes(
amount,
btchip_context_D.transactionBufferPointer,
8);
if (transaction_amount_add_be(
btchip_context_D.transactionContext
.transactionAmount,
btchip_context_D.transactionContext
.transactionAmount,
amount)) {
L_DEBUG_APP(("Overflow\n"));
goto fail;
}
L_DEBUG_BUF(
("Adding amount\n",
btchip_context_D.transactionBufferPointer,
8));
L_DEBUG_BUF(("New amount\n",
btchip_context_D.transactionContext
.transactionAmount,
8));
transaction_offset_increase(8);
} else {
btchip_context_D.transactionHashOption =
TRANSACTION_HASH_FULL;
transaction_offset_increase(36);
btchip_context_D.transactionHashOption = 0;
check_transaction_available(8); // save amount
os_memmove(
btchip_context_D.inputValue,
btchip_context_D.transactionBufferPointer,
8);
transaction_offset_increase(8);
btchip_context_D.transactionHashOption =
TRANSACTION_HASH_FULL;
}
} else if (!trustedInputFlag) {
// Only authorized in relaxed wallet and server
// modes
SB_CHECK(N_btchip.bkp.config.operationMode);
switch (SB_GET(N_btchip.bkp.config.operationMode)) {
case BTCHIP_MODE_WALLET:
if (!optionP2SHSkip2FA) {
L_DEBUG_APP(
("Untrusted input not authorized\n"));
goto fail;
}
break;
case BTCHIP_MODE_RELAXED_WALLET:
case BTCHIP_MODE_SERVER:
break;
default:
L_DEBUG_APP(
("Untrusted input not authorized\n"));
goto fail;
}
btchip_context_D.transactionBufferPointer++;
btchip_context_D.transactionDataRemaining--;
check_transaction_available(
36); // prevout : 32 hash + 4 index
transaction_offset_increase(36);
L_DEBUG_APP(("Marking relaxed input\n"));
btchip_context_D.transactionContext.relaxed = 1;
/*
L_DEBUG_APP(("Clearing P2SH consumption\n"));
btchip_context_D.transactionContext.consumeP2SH = 0;
*/
} else {
trustedInputLength = *(
btchip_context_D.transactionBufferPointer + 1);
if ((trustedInputLength > sizeof(trustedInput)) ||
(trustedInputLength < 8)) {
L_DEBUG_APP(("Invalid trusted input size\n"));
goto fail;
}
check_transaction_available(2 + trustedInputLength);
if (!cx_des(
(cx_des_key_t *)&N_btchip.bkp
.trustedinput_key,
CX_LAST | CX_PAD_NONE | CX_VERIFY |
CX_CHAIN_CBC,
btchip_context_D.transactionBufferPointer +
2,
trustedInputLength - 8,
btchip_context_D.transactionBufferPointer +
2 + trustedInputLength - 8)) {
L_DEBUG_APP(("Invalid signature\n"));
goto fail;
}
os_memmove(
trustedInput,
btchip_context_D.transactionBufferPointer + 2,
trustedInputLength - 8);
if (trustedInput[0] != MAGIC_TRUSTED_INPUT) {
L_DEBUG_APP(("Failed to verify trusted input "
"signature\n"));
goto fail;
}
// Update the hash with prevout data
savePointer =
btchip_context_D.transactionBufferPointer;
/*
// Check if a P2SH script is used
if ((trustedInput[1] & FLAG_TRUSTED_INPUT_P2SH) ==
0) {
L_DEBUG_APP(("Clearing P2SH consumption\n"));
btchip_context_D.transactionContext.consumeP2SH =
0;
}
*/
btchip_context_D.transactionBufferPointer =
trustedInput + 4;
L_DEBUG_BUF((
"Trusted input hash\n",
btchip_context_D.transactionBufferPointer, 36));
transaction_offset(36);
btchip_context_D.transactionBufferPointer =
savePointer + (2 + trustedInputLength);
btchip_context_D.transactionDataRemaining -=
(2 + trustedInputLength);
// Update the amount
btchip_swap_bytes(amount, trustedInput + 40, 8);
if (transaction_amount_add_be(
btchip_context_D.transactionContext
.transactionAmount,
btchip_context_D.transactionContext
.transactionAmount,
amount)) {
L_DEBUG_APP(("Overflow\n"));
goto fail;
}
L_DEBUG_BUF(
("Adding amount\n", (trustedInput + 40), 8));
L_DEBUG_BUF(("New amount\n",
btchip_context_D.transactionContext
.transactionAmount,
8));
}
if (!btchip_context_D.usingSegwit) {
// Do not include the input script length + value in
// the authentication hash
btchip_context_D.transactionHashOption =
TRANSACTION_HASH_FULL;
}
}
// Read the script length
btchip_context_D.transactionContext.scriptRemaining =
transaction_get_varint();
L_DEBUG_APP(
("Script to read " DEBUG_LONG "\n",
btchip_context_D.transactionContext.scriptRemaining));
if ((parseMode == PARSE_MODE_SIGNATURE) &&
!trustedInputFlag && !btchip_context_D.usingSegwit) {
// Only proceeds if this is not to be signed - so length
// should be null
if (btchip_context_D.transactionContext
.scriptRemaining != 0) {
L_DEBUG_APP(("Request to sign relaxed input\n"));
if (!optionP2SHSkip2FA) {
goto fail;
}
}
}
// Move on
btchip_context_D.transactionContext.transactionState =
BTCHIP_TRANSACTION_INPUT_HASHING_IN_PROGRESS_INPUT_SCRIPT;
// no break is intentional
}
case BTCHIP_TRANSACTION_INPUT_HASHING_IN_PROGRESS_INPUT_SCRIPT: {
unsigned char dataAvailable;
L_DEBUG_APP(
("Process input script, remaining " DEBUG_LONG "\n",
btchip_context_D.transactionContext.scriptRemaining));
if (btchip_context_D.transactionDataRemaining < 1) {
// No more data to read, ok
goto ok;
}
// Scan for P2SH consumption - huge shortcut, but fine
// enough
// Also usable in SegWit mode
if (btchip_context_D.transactionContext.scriptRemaining ==
1) {
if (*btchip_context_D.transactionBufferPointer ==
OP_CHECKMULTISIG) {
if (optionP2SHSkip2FA) {
L_DEBUG_APP(("Marking P2SH consumption\n"));
btchip_context_D.transactionContext
.consumeP2SH = 1;
}
} else {
// When using the P2SH shortcut, all inputs must use
// P2SH
L_DEBUG_APP(("Disabling P2SH consumption\n"));
btchip_context_D.transactionContext.consumeP2SH = 0;
}
transaction_offset_increase(1);
btchip_context_D.transactionContext.scriptRemaining--;
}
if (btchip_context_D.transactionContext.scriptRemaining ==
0) {
if (parseMode == PARSE_MODE_SIGNATURE) {
if (!btchip_context_D.usingSegwit) {
// Restore dual hash for signature +
// authentication
btchip_context_D.transactionHashOption =
TRANSACTION_HASH_BOTH;
} else {
if (btchip_context_D.segwitParsedOnce) {
// Append the saved value
L_DEBUG_BUF(("SEGWIT Add value\n",
btchip_context_D.inputValue,
8));
cx_hash(&btchip_context_D
.transactionHashFull.header,
0, btchip_context_D.inputValue, 8,
NULL);
}
}
}
// Sequence
check_transaction_available(4);
if (btchip_context_D.usingSegwit &&
!btchip_context_D.segwitParsedOnce) {
cx_hash(&btchip_context_D.segwit.hash.hashSequence
.header,
0,
btchip_context_D.transactionBufferPointer,
4, NULL);
}
transaction_offset_increase(4);
// Move to next input
btchip_context_D.transactionContext
.transactionRemainingInputsOutputs--;
btchip_context_D.transactionContext
.transactionCurrentInputOutput++;
btchip_context_D.transactionContext.transactionState =
BTCHIP_TRANSACTION_DEFINED_WAIT_INPUT;
continue;
}
// Save the last script byte for the P2SH check
dataAvailable =
(btchip_context_D.transactionDataRemaining >
btchip_context_D.transactionContext
.scriptRemaining -
1
? btchip_context_D.transactionContext
.scriptRemaining -
1
: btchip_context_D.transactionDataRemaining);
if (dataAvailable == 0) {
goto ok;
}
transaction_offset_increase(dataAvailable);
btchip_context_D.transactionContext.scriptRemaining -=
dataAvailable;
break;
}
case BTCHIP_TRANSACTION_INPUT_HASHING_DONE: {
L_DEBUG_APP(("Input hashing done\n"));
if (parseMode == PARSE_MODE_SIGNATURE) {
// inputs have been prepared, stop the parsing here
if (btchip_context_D.usingSegwit &&
!btchip_context_D.segwitParsedOnce) {
unsigned char hashedPrevouts[32];
unsigned char hashedSequence[32];
// Flush the cache
cx_hash(&btchip_context_D.segwit.hash.hashPrevouts
.header,
CX_LAST, hashedPrevouts, 0, hashedPrevouts);
cx_sha256_init(
&btchip_context_D.segwit.hash.hashPrevouts);
cx_hash(&btchip_context_D.segwit.hash.hashPrevouts
.header,
CX_LAST, hashedPrevouts,
sizeof(hashedPrevouts), hashedPrevouts);
cx_hash(&btchip_context_D.segwit.hash.hashSequence
.header,
CX_LAST, hashedSequence, 0, hashedSequence);
cx_sha256_init(
&btchip_context_D.segwit.hash.hashSequence);
cx_hash(&btchip_context_D.segwit.hash.hashSequence
.header,
CX_LAST, hashedSequence,
sizeof(hashedSequence), hashedSequence);
os_memmove(
btchip_context_D.segwit.cache.hashedPrevouts,
hashedPrevouts, sizeof(hashedPrevouts));
os_memmove(
btchip_context_D.segwit.cache.hashedSequence,
hashedSequence, sizeof(hashedSequence));
L_DEBUG_BUF(
("hashPrevout\n",
btchip_context_D.segwit.cache.hashedPrevouts,
32));
L_DEBUG_BUF(
("hashSequence\n",
btchip_context_D.segwit.cache.hashedSequence,
32));
}
if (btchip_context_D.usingSegwit &&
btchip_context_D.segwitParsedOnce) {
L_DEBUG_BUF(
("SEGWIT hashedOutputs\n",
btchip_context_D.segwit.cache.hashedOutputs,
sizeof(btchip_context_D.segwit.cache
.hashedOutputs)));
cx_hash(
&btchip_context_D.transactionHashFull.header, 0,
btchip_context_D.segwit.cache.hashedOutputs,
sizeof(btchip_context_D.segwit.cache
.hashedOutputs),
NULL);
btchip_context_D.transactionContext
.transactionState =
BTCHIP_TRANSACTION_SIGN_READY;
} else {
btchip_context_D.transactionContext
.transactionState =
BTCHIP_TRANSACTION_PRESIGN_READY;
}
continue;
}
if (btchip_context_D.transactionDataRemaining < 1) {
// No more data to read, ok
goto ok;
}
// Number of outputs
btchip_context_D.transactionContext
.transactionRemainingInputsOutputs =
transaction_get_varint();
btchip_context_D.transactionContext
.transactionCurrentInputOutput = 0;
L_DEBUG_APP(("Number of outputs : " DEBUG_LONG "\n",
btchip_context_D.transactionContext
.transactionRemainingInputsOutputs));
// Ready to proceed
btchip_context_D.transactionContext.transactionState =
BTCHIP_TRANSACTION_DEFINED_WAIT_OUTPUT;
// no break is intentional
}
case BTCHIP_TRANSACTION_DEFINED_WAIT_OUTPUT: {
if (btchip_context_D.transactionContext
.transactionRemainingInputsOutputs == 0) {
// No more outputs to hash, move forward
btchip_context_D.transactionContext.transactionState =
BTCHIP_TRANSACTION_OUTPUT_HASHING_DONE;
continue;
}
if (btchip_context_D.transactionDataRemaining < 1) {
// No more data to read, ok
goto ok;
}
// Amount
check_transaction_available(8);
if ((parseMode == PARSE_MODE_TRUSTED_INPUT) &&
(btchip_context_D.transactionContext
.transactionCurrentInputOutput ==
btchip_context_D.transactionTargetInput)) {
// Save the amount
os_memmove(btchip_context_D.transactionContext
.transactionAmount,
btchip_context_D.transactionBufferPointer,
8);
btchip_context_D.trustedInputProcessed = 1;
}
transaction_offset_increase(8);
// Read the script length
btchip_context_D.transactionContext.scriptRemaining =
transaction_get_varint();
L_DEBUG_APP(
("Script to read " DEBUG_LONG "\n",
btchip_context_D.transactionContext.scriptRemaining));
// Move on
btchip_context_D.transactionContext.transactionState =
BTCHIP_TRANSACTION_OUTPUT_HASHING_IN_PROGRESS_OUTPUT_SCRIPT;
// no break is intentional
}
case BTCHIP_TRANSACTION_OUTPUT_HASHING_IN_PROGRESS_OUTPUT_SCRIPT: {
unsigned char dataAvailable;
L_DEBUG_APP(
("Process output script, remaining " DEBUG_LONG "\n",
btchip_context_D.transactionContext.scriptRemaining));
/*
// Special check if consuming a P2SH script
if (parseMode == PARSE_MODE_TRUSTED_INPUT) {
// Assume the full input script is sent in a single APDU,
then do the ghetto validation
if ((btchip_context_D.transactionBufferPointer[0] ==
OP_HASH160) &&
(btchip_context_D.transactionBufferPointer[btchip_context_D.transactionDataRemaining
- 1] == OP_EQUAL)) {
L_DEBUG_APP(("Marking P2SH output\n"));
btchip_context_D.transactionContext.consumeP2SH = 1;
}
}
*/
if (btchip_context_D.transactionDataRemaining < 1) {
// No more data to read, ok
goto ok;
}
if (btchip_context_D.transactionContext.scriptRemaining ==
0) {
// Move to next output
btchip_context_D.transactionContext
.transactionRemainingInputsOutputs--;
btchip_context_D.transactionContext
.transactionCurrentInputOutput++;
btchip_context_D.transactionContext.transactionState =
BTCHIP_TRANSACTION_DEFINED_WAIT_OUTPUT;
continue;
}
dataAvailable =
(btchip_context_D.transactionDataRemaining >
btchip_context_D.transactionContext
.scriptRemaining
? btchip_context_D.transactionContext
.scriptRemaining
: btchip_context_D.transactionDataRemaining);
if (dataAvailable == 0) {
goto ok;
}
transaction_offset_increase(dataAvailable);
btchip_context_D.transactionContext.scriptRemaining -=
dataAvailable;
break;
}
case BTCHIP_TRANSACTION_OUTPUT_HASHING_DONE: {
L_DEBUG_APP(("Output hashing done\n"));
if (btchip_context_D.transactionDataRemaining < 1) {
// No more data to read, ok
goto ok;
}
// Locktime
check_transaction_available(4);
transaction_offset_increase(4);
btchip_context_D.transactionContext.transactionState =
BTCHIP_TRANSACTION_PARSED;
// no break is intentional
}
case BTCHIP_TRANSACTION_PARSED: {
L_DEBUG_APP(("Transaction parsed\n"));
goto ok;
}
case BTCHIP_TRANSACTION_PRESIGN_READY: {
L_DEBUG_APP(("Presign ready\n"));
goto ok;
}
case BTCHIP_TRANSACTION_SIGN_READY: {
L_DEBUG_APP(("Sign ready\n"));
goto ok;
}
}
}
fail:
L_DEBUG_APP(("Transaction parse - fail\n"));
THROW(EXCEPTION);
}
CATCH_OTHER(e) {
L_DEBUG_APP(("Transaction parse - surprise fail\n"));
btchip_context_D.transactionContext.transactionState =
BTCHIP_TRANSACTION_NONE;
btchip_set_check_internal_structure_integrity(1);
THROW(e);
}
ok: // before the finally to restore the surrounding context if an exception
// is raised during finally
FINALLY {
btchip_set_check_internal_structure_integrity(1);
}
}
END_TRY;
}

42
src/btchip_transaction.h Normal file
View File

@ -0,0 +1,42 @@
/*******************************************************************************
* Ledger Blue - Bitcoin Wallet
* (c) 2016 Ledger
*
* 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.
********************************************************************************/
#include "btchip_secure_value.h"
#ifndef BTCHIP_TRANSACTION_H
#define BTCHIP_TRANSACTION_H
#define TRANSACTION_HASH_NONE 0x00
#define TRANSACTION_HASH_FULL 0x01
#define TRANSACTION_HASH_AUTHORIZATION 0x02
#define TRANSACTION_HASH_BOTH 0x03
#define PARSE_MODE_TRUSTED_INPUT 0x01
#define PARSE_MODE_SIGNATURE 0x02
void transaction_parse(unsigned char parseMode);
unsigned char transaction_amount_add_be(unsigned char *target,
unsigned char WIDE *a,
unsigned char WIDE *b);
unsigned char transaction_amount_sub_be(unsigned char *target,
unsigned char WIDE *a,
unsigned char WIDE *b);
#endif

603
src/main.c Normal file
View File

@ -0,0 +1,603 @@
/*******************************************************************************
* Ledger Blue - Bitcoin Wallet
* (c) 2016 Ledger
*
* 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.
********************************************************************************/
#include "os.h"
#include "cx.h"
#include "os_io_seproxyhal.h"
#include "string.h"
#include "btchip_internal.h"
#include "btchip_bagl_extensions.h"
void io_usb_enable(unsigned char enabled);
void os_boot(void);
unsigned char G_io_seproxyhal_spi_buffer[IO_SEPROXYHAL_BUFFER_SIZE_B];
volatile unsigned char uiDoneAfterDraw;
volatile unsigned char uiDone;
volatile unsigned char transactionVerified;
volatile unsigned int current_element;
volatile bagl_element_t *active_screen;
volatile unsigned int active_screen_element_count;
volatile bagl_element_t *active_screen2;
volatile unsigned int active_screen2_element_count;
volatile unsigned char display_changed;
volatile enum {
BAGL_BTCHIP_IDLE,
BAGL_BTCHIP_VERIFY,
} btchip_ui_mode = BAGL_BTCHIP_IDLE;
volatile char fullAmount[20]; // full amount
volatile char addressSummary[20]; // beginning of the output address ... end of
// the address
volatile char address1[20]; // full first part of the output address
volatile char address2[20]; // full last part of the output address
volatile unsigned char generalStatus;
unsigned int io_seproxyhal_touch_verify_cancel(bagl_element_t *e);
unsigned int io_seproxyhal_touch_verify_ok(bagl_element_t *e);
unsigned int io_seproxyhal_touch_exit(bagl_element_t *e);
static const bagl_element_t const bagl_ui_erase_all[] = {
{{BAGL_RECTANGLE, 0x00, 0, 0, 320, 480, 0, 0, BAGL_FILL, 0xf9f9f9, 0xf9f9f9,
0, 0},
NULL,
0,
0,
0,
NULL,
NULL,
NULL},
};
static const bagl_element_t const bagl_ui_idle[] = {
// type id x y w h s r fill
// fg bg font icon text, out, over, touch
{{BAGL_RECTANGLE, 0x00, 0, 0, 320, 60, 0, 0, BAGL_FILL, 0x1d2028, 0x1d2028,
0, 0},
NULL,
0,
0,
0,
NULL,
NULL,
NULL},
{{BAGL_LABEL, 0x00, 20, 0, 320, 60, 0, 0, BAGL_FILL, 0xFFFFFF, 0x1d2028,
BAGL_FONT_OPEN_SANS_LIGHT_14px | BAGL_FONT_ALIGNMENT_MIDDLE, 0},
"Ledger Blue",
0,
0,
0,
NULL,
NULL,
NULL},
{{BAGL_LABEL, 0x00, 0, 90, 320, 32, 0, 0, 0, 0x000000, 0xF9F9F9,
BAGL_FONT_OPEN_SANS_LIGHT_14px | BAGL_FONT_ALIGNMENT_CENTER, 0},
"$DEVICENAME",
0,
0,
0,
NULL,
NULL,
NULL},
{{BAGL_LABEL, 0x00, 0, 150, 320, 32, 0, 0, 0, 0x000000, 0xF9F9F9,
BAGL_FONT_OPEN_SANS_LIGHT_14px | BAGL_FONT_ALIGNMENT_CENTER, 0},
"Ready",
0,
0,
0,
NULL,
NULL,
NULL},
{{BAGL_BUTTON | BAGL_FLAG_TOUCHABLE, 0x00, 165, 225, 120, 40, 0, 6,
BAGL_FILL, 0x41ccb4, 0xF9F9F9,
BAGL_FONT_OPEN_SANS_LIGHT_14px | BAGL_FONT_ALIGNMENT_CENTER |
BAGL_FONT_ALIGNMENT_MIDDLE,
0},
"EXIT",
0,
0x37ae99,
0xF9F9F9,
(bagl_element_callback_t)io_seproxyhal_touch_exit,
NULL,
NULL},
};
bagl_element_t const bagl_ui_verify[] = {
// type id x y w h s r fill
// fg bg font icon text, out, over, touch
{{BAGL_RECTANGLE, 0x00, 0, 0, 320, 60, 0, 0, BAGL_FILL, 0x1d2028, 0x1d2028,
0, 0},
NULL,
0,
0,
0,
NULL,
NULL,
NULL},
{{BAGL_LABEL, 0x00, 20, 0, 320, 60, 0, 0, BAGL_FILL, 0xFFFFFF, 0x1d2028,
BAGL_FONT_OPEN_SANS_LIGHT_14px | BAGL_FONT_ALIGNMENT_MIDDLE, 0},
"Ledger Blue",
0,
0,
0,
NULL,
NULL,
NULL},
{{BAGL_BUTTON | BAGL_FLAG_TOUCHABLE, 0x00, 35, 385, 120, 40, 0, 6,
BAGL_FILL, 0xcccccc, 0xF9F9F9,
BAGL_FONT_OPEN_SANS_LIGHT_14px | BAGL_FONT_ALIGNMENT_CENTER |
BAGL_FONT_ALIGNMENT_MIDDLE,
0},
"CANCEL",
0,
0x37ae99,
0xF9F9F9,
(bagl_element_callback_t)io_seproxyhal_touch_verify_cancel,
NULL,
NULL},
{{BAGL_BUTTON | BAGL_FLAG_TOUCHABLE, 0x00, 165, 385, 120, 40, 0, 6,
BAGL_FILL, 0x41ccb4, 0xF9F9F9,
BAGL_FONT_OPEN_SANS_LIGHT_14px | BAGL_FONT_ALIGNMENT_CENTER |
BAGL_FONT_ALIGNMENT_MIDDLE,
0},
"CONFIRM",
0,
0x37ae99,
0xF9F9F9,
(bagl_element_callback_t)io_seproxyhal_touch_verify_ok,
NULL,
NULL},
{{BAGL_LABEL, 0x00, 0, 147, 320, 32, 0, 0, 0, 0x000000, 0xF9F9F9,
BAGL_FONT_OPEN_SANS_LIGHT_14px | BAGL_FONT_ALIGNMENT_CENTER, 0},
"CONFIRM TRANSACTION",
0,
0,
0,
NULL,
NULL,
NULL},
{{BAGL_LABEL, 0x00, 0, 185, 320, 32, 0, 0, 0, 0x000000, 0xF9F9F9,
BAGL_FONT_OPEN_SANS_LIGHT_14px | BAGL_FONT_ALIGNMENT_CENTER, 0},
"Default wallet",
0,
0,
0,
NULL,
NULL,
NULL},
{{BAGL_LABEL, 0x00, 0, 217, 320, 33, 0, 0, 0, 0x000000, 0xF9F9F9,
BAGL_FONT_OPEN_SANS_LIGHT_16px | BAGL_FONT_ALIGNMENT_CENTER, 0},
(const char *)fullAmount,
0,
0,
0,
NULL,
NULL,
NULL},
{{BAGL_LABEL, 0x00, 0, 280, 320, 33, 0, 0, 0, 0x000000, 0xF9F9F9,
BAGL_FONT_OPEN_SANS_LIGHT_16px | BAGL_FONT_ALIGNMENT_CENTER, 0},
(const char *)addressSummary,
0,
0,
0,
NULL,
NULL,
NULL},
{{BAGL_LABEL, 0x00, 0, 310, 320, 33, 0, 0, 0, 0x000000, 0xF9F9F9,
BAGL_FONT_OPEN_SANS_LIGHT_14px | BAGL_FONT_ALIGNMENT_CENTER, 0},
(const char *)address1,
0,
0,
0,
NULL,
NULL,
NULL},
{{BAGL_LABEL, 0x00, 0, 330, 320, 33, 0, 0, 0, 0x000000, 0xF9F9F9,
BAGL_FONT_OPEN_SANS_LIGHT_14px | BAGL_FONT_ALIGNMENT_CENTER, 0},
(const char *)address2,
0,
0,
0,
NULL,
NULL,
NULL},
};
// override point, but nothing more to do
void io_seproxyhal_display(const bagl_element_t *element) {
display_changed = 1;
io_seproxyhal_display_default((bagl_element_t *)element);
}
void display_init(void) {
uiDone = 0;
uiDoneAfterDraw = 0;
display_changed = 0;
active_screen2 = NULL;
}
void displayHome(void) {
btchip_ui_mode = BAGL_BTCHIP_IDLE;
current_element = 0;
active_screen_element_count = sizeof(bagl_ui_idle) / sizeof(bagl_element_t);
active_screen = (bagl_element_t *)bagl_ui_idle;
io_seproxyhal_display(&bagl_ui_erase_all[0]);
}
// off
unsigned int io_seproxyhal_touch_exit(bagl_element_t *e) {
/*
G_io_seproxyhal_spi_buffer[0] = SEPROXYHAL_TAG_DEVICE_OFF;
G_io_seproxyhal_spi_buffer[1] = 0;
G_io_seproxyhal_spi_buffer[2] = 0;
io_seproxyhal_spi_send(G_io_seproxyhal_spi_buffer, 3);
*/
// go back to the home screen
os_sched_exit(0);
return 0; // DO NOT REDRAW THE BUTTON
}
// verify cancel
unsigned int io_seproxyhal_touch_verify_cancel(bagl_element_t *e) {
transactionVerified = 0;
uiDoneAfterDraw = 1;
displayHome();
return 0; // DO NOT REDRAW THE BUTTON
}
// verify ok
unsigned int io_seproxyhal_touch_verify_ok(bagl_element_t *e) {
transactionVerified = 1;
uiDoneAfterDraw = 1;
displayHome();
return 0; // DO NOT REDRAW THE BUTTON
}
void reset(void) {
}
unsigned short io_exchange_al(unsigned char channel, unsigned short tx_len) {
switch (channel & ~(IO_FLAGS)) {
case CHANNEL_KEYBOARD:
break;
// multiplexed io exchange over a SPI channel and TLV encapsulated protocol
case CHANNEL_SPI:
if (tx_len) {
io_seproxyhal_spi_send(G_io_apdu_buffer, tx_len);
if (channel & IO_RESET_AFTER_REPLIED) {
reset();
}
return 0; // nothing recPeived from the master so far (it's a tx
// transaction)
} else {
return io_seproxyhal_spi_recv(G_io_apdu_buffer,
sizeof(G_io_apdu_buffer), 0);
}
default:
THROW(INVALID_PARAMETER);
}
return 0;
}
unsigned int usb_enable_request;
unsigned char io_event(unsigned char channel) {
// nothing done with the event, throw an error on the transport layer if
// needed
unsigned int offset = 0;
// just reply "amen"
// add a "pairing ok" tag if necessary
// can't have more than one tag in the reply, not supported yet.
switch (G_io_seproxyhal_spi_buffer[0]) {
case SEPROXYHAL_TAG_BLE_PAIRING_ATTEMPT_EVENT:
G_io_seproxyhal_spi_buffer[offset++] = SEPROXYHAL_TAG_PAIRING_STATUS;
G_io_seproxyhal_spi_buffer[offset++] = 0;
G_io_seproxyhal_spi_buffer[offset++] = 1;
G_io_seproxyhal_spi_buffer[offset++] = 1;
io_seproxyhal_spi_send(G_io_seproxyhal_spi_buffer, offset);
break;
case SEPROXYHAL_TAG_FINGER_EVENT:
// TOUCH & RELEASE
display_changed = 0; // detect screen display requests, to determine if
// general status is required or not
io_seproxyhal_touch((const bagl_element_t *)active_screen,
active_screen_element_count,
(G_io_seproxyhal_spi_buffer[4] << 8) |
(G_io_seproxyhal_spi_buffer[5] & 0xFF),
(G_io_seproxyhal_spi_buffer[6] << 8) |
(G_io_seproxyhal_spi_buffer[7] & 0xFF),
// map events
G_io_seproxyhal_spi_buffer[3]);
if (!display_changed) {
goto general_status;
}
break;
#ifdef HAVE_BLE
// Make automatically discoverable again when disconnected
case SEPROXYHAL_TAG_BLE_CONNECTION_EVENT:
if (G_io_seproxyhal_spi_buffer[3] == 0) {
// TODO : cleaner reset sequence
// first disable BLE before turning it off
G_io_seproxyhal_spi_buffer[0] = SEPROXYHAL_TAG_BLE_RADIO_POWER;
G_io_seproxyhal_spi_buffer[1] = 0;
G_io_seproxyhal_spi_buffer[2] = 1;
G_io_seproxyhal_spi_buffer[3] = 0;
io_seproxyhal_spi_send(G_io_seproxyhal_spi_buffer, 4);
// send BLE power on (default parameters)
G_io_seproxyhal_spi_buffer[0] = SEPROXYHAL_TAG_BLE_RADIO_POWER;
G_io_seproxyhal_spi_buffer[1] = 0;
G_io_seproxyhal_spi_buffer[2] = 1;
G_io_seproxyhal_spi_buffer[3] = 3; // ble on & advertise
io_seproxyhal_spi_send(G_io_seproxyhal_spi_buffer, 5);
}
goto general_status;
#endif
case SEPROXYHAL_TAG_SESSION_START_EVENT:
#ifdef HAVE_BLE
// send BLE power on (default parameters)
G_io_seproxyhal_spi_buffer[0] = SEPROXYHAL_TAG_BLE_RADIO_POWER;
G_io_seproxyhal_spi_buffer[1] = 0;
G_io_seproxyhal_spi_buffer[2] = 1;
G_io_seproxyhal_spi_buffer[3] = 3; // ble on & advertise
io_seproxyhal_spi_send(G_io_seproxyhal_spi_buffer, 4);
#endif
// request usb startup after display done
usb_enable_request = 1;
display_init();
// display the home (erase the loader screen is mandatory, and not done
// by the loader)
displayHome();
// goto general_status;
break;
case SEPROXYHAL_TAG_DISPLAY_PROCESSED_EVENT:
if (active_screen2 != NULL) {
if (current_element < active_screen2_element_count) {
// continue displaying element if any to be processed again
io_seproxyhal_display(
(const bagl_element_t *)&active_screen2[current_element++]);
break;
} else {
active_screen2 = NULL;
current_element = active_screen_element_count;
}
} else {
if (current_element < active_screen_element_count) {
// continue displaying element if any to be processed again
io_seproxyhal_display(
(const bagl_element_t *)&active_screen[current_element++]);
break;
}
}
if (usb_enable_request) {
// enable usb support
io_usb_enable(1);
usb_enable_request = 0;
}
if (uiDoneAfterDraw) {
// Top level handle the general status along with the APDU response
uiDoneAfterDraw = 0;
uiDone = 1;
break;
}
// no break is intentional: always a general status after display event
generalStatus = 1;
default:
general_status:
// send a general status last command
offset = 0;
G_io_seproxyhal_spi_buffer[offset++] = SEPROXYHAL_TAG_GENERAL_STATUS;
G_io_seproxyhal_spi_buffer[offset++] = 0;
G_io_seproxyhal_spi_buffer[offset++] = 2;
G_io_seproxyhal_spi_buffer[offset++] =
SEPROXYHAL_TAG_GENERAL_STATUS_LAST_COMMAND >> 8;
G_io_seproxyhal_spi_buffer[offset++] =
SEPROXYHAL_TAG_GENERAL_STATUS_LAST_COMMAND;
io_seproxyhal_spi_send(G_io_seproxyhal_spi_buffer, offset);
}
// command has been processed, DO NOT reset the current APDU transport
return 1;
}
uint8_t prepare_full_output(unsigned int outputPos) {
unsigned int offset = 0;
int numberOutputs;
int i;
unsigned int currentPos = 0;
unsigned char amount[8], totalOutputAmount[8], fees[8];
char tmp[100];
// Parse output
os_memset(totalOutputAmount, 0, sizeof(totalOutputAmount));
numberOutputs = btchip_context_D.currentOutput[offset++];
if (numberOutputs > 3) {
screen_printf("Error : Too many outputs");
goto error;
}
for (i = 0; i < numberOutputs; i++) {
unsigned char nullAmount = 1;
unsigned int j;
for (j = 0; j < 8; j++) {
if (btchip_context_D.currentOutput[offset + j] != 0) {
nullAmount = 0;
break;
}
}
btchip_swap_bytes(amount, btchip_context_D.currentOutput + offset, 8);
transaction_amount_add_be(totalOutputAmount, totalOutputAmount, amount);
offset += 8; // skip amount
if (!btchip_output_script_is_regular(btchip_context_D.currentOutput +
offset) &&
!btchip_output_script_is_p2sh(btchip_context_D.currentOutput +
offset) &&
!(nullAmount && btchip_output_script_is_op_return(
btchip_context_D.currentOutput + offset))) {
screen_printf("Error : Unrecognized input script");
goto error;
}
offset += 1 + btchip_context_D.currentOutput[offset];
}
if (transaction_amount_sub_be(
fees, btchip_context_D.transactionContext.transactionAmount,
totalOutputAmount)) {
screen_printf("Error : Fees not consistant");
goto error;
}
// Format validation message
offset = 1;
btchip_context_D.tmp = (unsigned char *)tmp;
for (i = 0; i < numberOutputs; i++) {
if (!btchip_output_script_is_op_return(btchip_context_D.currentOutput +
offset + 8)) {
int addressOffset;
unsigned char address[21];
btchip_swap_bytes(amount, btchip_context_D.currentOutput + offset,
8);
offset += 8;
if (btchip_output_script_is_regular(btchip_context_D.currentOutput +
offset)) {
addressOffset = offset + 4;
address[0] = N_btchip.bkp.config.payToAddressVersion;
} else {
addressOffset = offset + 3;
address[0] = N_btchip.bkp.config.payToScriptHashVersion;
}
os_memmove(address + 1,
btchip_context_D.currentOutput + addressOffset, 20);
if (currentPos == outputPos) {
unsigned short textSize;
textSize = btchip_public_key_to_encoded_base58(
address, 21, (unsigned char *)tmp, sizeof(tmp), 0, 1);
tmp[textSize] = '\0';
// Prepare address
os_memmove((void *)address1, tmp, 18);
address1[18] = '\0';
os_memmove((void *)address2, tmp + 18, strlen(tmp) - 18);
address2[strlen(tmp) - 18] = '\0';
os_memmove((void *)addressSummary, tmp, 5);
os_memmove((void *)(addressSummary + 5), " ... ", 5);
os_memmove((void *)(addressSummary + 10), tmp + strlen(tmp) - 4,
4);
addressSummary[14] = '\0';
// Prepare amount
// TODO : match current coin version
btchip_context_D.tmp = (unsigned char *)fullAmount;
textSize = btchip_convert_hex_amount_to_displayable(amount);
os_memmove((void *)(fullAmount + textSize), " BTC", 4);
fullAmount[textSize + 4] = '\0';
break;
}
} else {
offset += 8;
}
offset += 1 + btchip_context_D.currentOutput[offset];
currentPos++;
}
return 1;
error:
return 0;
}
uint8_t btchip_bagl_confirm_full_output(unsigned int outputPos) {
uiDone = 0;
uiDoneAfterDraw = 0;
transactionVerified = 0;
if (!prepare_full_output(outputPos)) {
return 0;
}
btchip_ui_mode = BAGL_BTCHIP_VERIFY;
current_element = 0;
active_screen_element_count =
sizeof(bagl_ui_verify) / sizeof(bagl_element_t);
active_screen = (bagl_element_t *)bagl_ui_verify;
io_seproxyhal_display(&bagl_ui_erase_all[0]);
// Loop on the UI, general status will be sent when all components are
// displayed
while (!uiDone) {
unsigned int rx_len;
rx_len = io_seproxyhal_spi_recv(G_io_seproxyhal_spi_buffer,
sizeof(G_io_seproxyhal_spi_buffer), 0);
if ((rx_len - 3) != (unsigned int)U2(G_io_seproxyhal_spi_buffer[1],
G_io_seproxyhal_spi_buffer[2])) {
continue;
}
io_event(CHANNEL_SPI);
}
return transactionVerified;
}
void main_continue(void) {
// ensure exception will work as planned
os_boot();
BEGIN_TRY {
TRY {
io_seproxyhal_init();
screen_printf("ST31_APP booted.\n");
// fake the session start event
G_io_seproxyhal_spi_buffer[0] = SEPROXYHAL_TAG_SESSION_START_EVENT;
G_io_seproxyhal_spi_buffer[1] = 0;
G_io_seproxyhal_spi_buffer[2] = 1;
G_io_seproxyhal_spi_buffer[3] = 0;
io_event(CHANNEL_SPI);
btchip_context_init();
app_main();
}
CATCH_ALL {
for (;;)
;
}
FINALLY {
}
}
END_TRY;
}
__attribute__((section(".boot"))) int main(void) {
// exit critical section
__asm volatile("cpsie i");
main_continue();
return 0;
}

View File

@ -0,0 +1,157 @@
/**
******************************************************************************
* @file usbd_customhid.h
* @author MCD Application Team
* @version V2.2.0
* @date 13-June-2014
* @brief header file for the usbd_customhid.c file.
******************************************************************************
* @attention
*
* <h2><center>&copy; COPYRIGHT 2014 STMicroelectronics</center></h2>
*
* Licensed under MCD-ST Liberty SW License Agreement V2, (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.st.com/software_license_agreement_liberty_v2
*
* 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.
*
******************************************************************************
*/
/* Includes ------------------------------------------------------------------*/
#ifndef __USB_CUSTOM_HID_CORE_H_
#define __USB_CUSTOM_HID_CORE_H_
#include "usbd_ioreq.h"
/** @addtogroup STM32_USB_DEVICE_LIBRARY
* @{
*/
/** @defgroup USBD_CUSTOM_HID
* @brief This file is the Header file for USBD_custom_hid.c
* @{
*/
/** @defgroup USBD_CUSTOM_HID_Exported_Defines
* @{
*/
#define CUSTOM_HID_EPIN_ADDR 0x82
#define CUSTOM_HID_EPIN_SIZE 0x40
#define CUSTOM_HID_EPOUT_ADDR 0x02
#define CUSTOM_HID_EPOUT_SIZE 0x40
//#define USB_CUSTOM_HID_CONFIG_DESC_SIZ 75
//#define USB_CUSTOM_HID_DESC_SIZ 9
#define CUSTOM_HID_DESCRIPTOR_TYPE 0x21
#define CUSTOM_HID_REPORT_DESC 0x22
#define CUSTOM_HID_REQ_SET_PROTOCOL 0x0B
#define CUSTOM_HID_REQ_GET_PROTOCOL 0x03
#define CUSTOM_HID_REQ_SET_IDLE 0x0A
#define CUSTOM_HID_REQ_GET_IDLE 0x02
#define CUSTOM_HID_REQ_SET_REPORT 0x09
#define CUSTOM_HID_REQ_GET_REPORT 0x01
/**
* @}
*/
/** @defgroup USBD_CORE_Exported_TypesDefinitions
* @{
*/
typedef enum
{
CUSTOM_HID_IDLE = 0,
CUSTOM_HID_BUSY,
}
CUSTOM_HID_StateTypeDef;
typedef int8_t (* HIDInit_t) (void);
typedef int8_t (* HIDOutEvent_t) (uint8_t* hid_report);
typedef int8_t (* HIDDeInit_t) (void);
typedef struct _USBD_CUSTOM_HID_Itf
{
HIDInit_t Init;
HIDDeInit_t DeInit;
HIDOutEvent_t OutEvent;
}USBD_CUSTOM_HID_ItfTypeDef;
#include "usbd_customhid_if_template.h"
typedef struct
{
//uint8_t Report_buf[USBD_CUSTOM_HID_OUTREPORT_BUF_SIZE];
uint32_t Protocol;
uint32_t IdleState;
uint32_t AltSetting;
uint32_t IsReportAvailable;
CUSTOM_HID_StateTypeDef state;
}
USBD_CUSTOM_HID_HandleTypeDef;
/**
* @}
*/
/** @defgroup USBD_CORE_Exported_Macros
* @{
*/
/**
* @}
*/
/** @defgroup USBD_CORE_Exported_Variables
* @{
*/
extern const USBD_ClassTypeDef USBD_CUSTOM_HID;
#define USBD_CUSTOM_HID_CLASS &USBD_CUSTOM_HID
/**
* @}
*/
/** @defgroup USB_CORE_Exported_Functions
* @{
*/
uint8_t USBD_CUSTOM_HID_SendReport (USBD_HandleTypeDef *pdev,
uint8_t *report,
uint16_t len);
uint8_t USBD_CUSTOM_HID_RegisterInterface (USBD_HandleTypeDef *pdev,
USBD_CUSTOM_HID_ItfTypeDef *fops);
/**
* @}
*/
#endif // __USB_CUSTOM_HID_CORE_H_
/**
* @}
*/
/**
* @}
*/
/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

View File

@ -0,0 +1,913 @@
/**
******************************************************************************
* @file usbd_customhid.c
* @author MCD Application Team
* @version V2.2.0
* @date 13-June-2014
* @brief This file provides the CUSTOM_HID core functions.
*
* @verbatim
*
* ===================================================================
* CUSTOM_HID Class Description
* ===================================================================
* This module manages the CUSTOM_HID class V1.11 following the "Device Class Definition
* for Human Interface Devices (CUSTOM_HID) Version 1.11 Jun 27, 2001".
* This driver implements the following aspects of the specification:
* - The Boot Interface Subclass
* - Usage Page : Generic Desktop
* - Usage : Vendor
* - Collection : Application
*
* @note In HS mode and when the DMA is used, all variables and data structures
* dealing with the DMA during the transaction process should be 32-bit aligned.
*
*
* @endverbatim
*
******************************************************************************
* @attention
*
* <h2><center>&copy; COPYRIGHT 2014 STMicroelectronics</center></h2>
*
* Licensed under MCD-ST Liberty SW License Agreement V2, (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.st.com/software_license_agreement_liberty_v2
*
* 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.
*
******************************************************************************
*/
/* Includes ------------------------------------------------------------------*/
#include "usbd_customhid.h"
#include "usbd_desc.h"
#include "usbd_ctlreq.h"
#include "usbd_core.h"
#include "usbd_desc.h"
#include "usbd_conf.h"
#include "os.h"
/** @addtogroup STM32_USB_DEVICE_LIBRARY
* @{
*/
/** @defgroup USBD_CUSTOM_HID
* @brief usbd core module
* @{
*/
/** @defgroup USBD_CUSTOM_HID_Private_TypesDefinitions
* @{
*/
/**
* @}
*/
/** @defgroup USBD_CUSTOM_HID_Private_Defines
* @{
*/
/**
* @}
*/
/** @defgroup USBD_CUSTOM_HID_Private_Macros
* @{
*/
/**
* @}
*/
/** @defgroup USBD_CUSTOM_HID_Private_FunctionPrototypes
* @{
*/
uint8_t *USBD_HID_DeviceDescriptor(USBD_SpeedTypeDef speed, uint16_t *length);
uint8_t *USBD_HID_LangIDStrDescriptor(USBD_SpeedTypeDef speed, uint16_t *length);
uint8_t *USBD_HID_ManufacturerStrDescriptor (USBD_SpeedTypeDef speed, uint16_t *length);
uint8_t *USBD_HID_ProductStrDescriptor (USBD_SpeedTypeDef speed, uint16_t *length);
uint8_t *USBD_HID_SerialStrDescriptor(USBD_SpeedTypeDef speed, uint16_t *length);
uint8_t *USBD_HID_ConfigStrDescriptor(USBD_SpeedTypeDef speed, uint16_t *length);
uint8_t *USBD_HID_InterfaceStrDescriptor(USBD_SpeedTypeDef speed, uint16_t *length);
#ifdef USB_SUPPORT_USER_STRING_DESC
uint8_t *USBD_HID_USRStringDesc (USBD_SpeedTypeDef speed, uint8_t idx, uint16_t *length);
#endif /* USB_SUPPORT_USER_STRING_DESC */
/* Private functions ---------------------------------------------------------*/
static void IntToUnicode (uint32_t value , uint8_t *pbuf , uint8_t len);
static void Get_SerialNum(void);
static uint8_t USBD_CUSTOM_HID_Init (USBD_HandleTypeDef *pdev,
uint8_t cfgidx);
static uint8_t USBD_CUSTOM_HID_DeInit (USBD_HandleTypeDef *pdev,
uint8_t cfgidx);
static uint8_t USBD_CUSTOM_HID_Setup (USBD_HandleTypeDef *pdev,
USBD_SetupReqTypedef *req);
static uint8_t *USBD_CUSTOM_HID_GetCfgDesc (uint16_t *length);
static uint8_t *USBD_CUSTOM_HID_GetDeviceQualifierDesc (uint16_t *length);
static uint8_t USBD_CUSTOM_HID_DataIn (USBD_HandleTypeDef *pdev, uint8_t epnum);
static uint8_t USBD_CUSTOM_HID_DataOut (USBD_HandleTypeDef *pdev, uint8_t epnum, uint8_t* hid_report);
static uint8_t USBD_CUSTOM_HID_EP0_RxReady (USBD_HandleTypeDef *pdev);
/**
* @}
*/
/** @defgroup USBD_CUSTOM_HID_Private_Variables
* @{
*/
const USBD_ClassTypeDef const USBD_CUSTOM_HID =
{
USBD_CUSTOM_HID_Init,
USBD_CUSTOM_HID_DeInit,
USBD_CUSTOM_HID_Setup,
NULL, /*EP0_TxSent*/
USBD_CUSTOM_HID_EP0_RxReady, /*EP0_RxReady*/ /* STATUS STAGE IN */
USBD_CUSTOM_HID_DataIn, /*DataIn*/
USBD_CUSTOM_HID_DataOut,
NULL, /*SOF */
NULL,
NULL,
USBD_CUSTOM_HID_GetCfgDesc,
USBD_CUSTOM_HID_GetCfgDesc,
USBD_CUSTOM_HID_GetCfgDesc,
USBD_CUSTOM_HID_GetDeviceQualifierDesc,
};
#define USBD_VID 0x2C97
#define USBD_PID 0x0000
#define USBD_LANGID_STRING 0x409
/* USB Standard Device Descriptor */
const uint8_t const USBD_LangIDDesc[USB_LEN_LANGID_STR_DESC]=
{
USB_LEN_LANGID_STR_DESC,
USB_DESC_TYPE_STRING,
LOBYTE(USBD_LANGID_STRING),
HIBYTE(USBD_LANGID_STRING),
};
const uint8_t const USB_SERIAL_STRING[] =
{
0x2,
USB_DESC_TYPE_STRING,
};
const uint8_t const USBD_MANUFACTURER_STRING[] = {
6*2+2,
USB_DESC_TYPE_STRING,
'L', 0,
'e', 0,
'd', 0,
'g', 0,
'e', 0,
'r', 0,
};
const uint8_t const USBD_PRODUCT_FS_STRING[] = {
11*2+2,
USB_DESC_TYPE_STRING,
'L', 0,
'e', 0,
'd', 0,
'g', 0,
'e', 0,
'r', 0,
' ', 0,
'B', 0,
'l', 0,
'u', 0,
'e', 0,
};
#define USBD_INTERFACE_FS_STRING USBD_PRODUCT_FS_STRING
#define USBD_CONFIGURATION_FS_STRING USBD_PRODUCT_FS_STRING
#ifdef HAVE_IO_USB_CDC
/* USB CUSTOM_HID device Configuration Descriptor */
__ALIGN_BEGIN const uint8_t const USBD_CUSTOM_HID_CfgDesc[USB_CUSTOM_HID_CONFIG_DESC_SIZ] __ALIGN_END =
{
0x09, /* bLength: Configuration Descriptor size */
USB_DESC_TYPE_CONFIGURATION, /* bDescriptorType: Configuration */
USB_CUSTOM_HID_CONFIG_DESC_SIZ,
/* wTotalLength: Bytes returned */
0x00,
0x02, /*bNumInterfaces: 1 interface*/
0x01, /*bConfigurationValue: Configuration value*/
0x00, /*iConfiguration: Index of string descriptor describing
the configuration*/
0xC0, /*bmAttributes: bus powered */
0x32, /*MaxPower 100 mA: this current is used for detecting Vbus*/
/************** Descriptor of CUSTOM CDC interface association ****/
0x08,
11, // interface association
0, // start at interface 0
2, // 2 interfaces
2, // class communications
2, // abstract(modem)
0, // nowrapping
0, // iInterfaceAssociation
/************** Descriptor of CUSTOM HID interface ****************/
/* 09 */
0x09, /*bLength: Interface Descriptor size*/
USB_DESC_TYPE_INTERFACE,/*bDescriptorType: Interface descriptor type*/
0x00, /*bInterfaceNumber: Number of Interface*/
0x00, /*bAlternateSetting: Alternate setting*/
0x01, /*bNumEndpoints*/
0x02, /*bInterfaceClass: CDC*/
0x02,
0x00,
0, /*iInterface: Index of string descriptor*/
0x05,
0x24,
0x00,
0x10,
0x01,
0x05,
0x24,
0x01,
0x00,
0x01,
0x04,
0x24,
0x02,
//0x02, // supported set line state
0x00, // don't supported set line state
0x05,
0x24,
0x06,
0x00,
0x01,
0x07,
USB_DESC_TYPE_ENDPOINT,
0x83,
0x03,
0x08, // length ep low
0x00, // length ep high
0x08,
/************** Descriptor of CUSTOM HID interface ****************/
/* 09 */
0x09, /*bLength: Interface Descriptor size*/
USB_DESC_TYPE_INTERFACE,/*bDescriptorType: Interface descriptor type*/
0x01, /*bInterfaceNumber: Number of Interface*/
0x00, /*bAlternateSetting: Alternate setting*/
0x02, /*bNumEndpoints*/
0x0A, /*bInterfaceClass: CUSTOM_HID*/
0x00, /*bInterfaceSubClass : 1=BOOT, 0=no boot*/
0x00, /*nInterfaceProtocol : 0=none, 1=keyboard, 2=mouse*/
0, /*iInterface: Index of string descriptor*/
0x07,
USB_DESC_TYPE_ENDPOINT,
CUSTOM_HID_EPIN_ADDR,
0x02,
CUSTOM_HID_EPIN_SIZE, // length ep low
0x00, // length ep high
0x00,
0x07,
USB_DESC_TYPE_ENDPOINT,
CUSTOM_HID_EPOUT_ADDR,
0x02,
CUSTOM_HID_EPOUT_SIZE, // length ep low
0x00, // length ep high
0x00,
} ;
#else
const uint8_t const CUSTOM_HID_ReportDesc[] = {
0x06, 0xA0, 0xFF, // Usage page (vendor defined)
0x09, 0x01, // Usage ID (vendor defined)
0xA1, 0x01, // Collection (application)
// The Input report
0x09, 0x03, // Usage ID - vendor defined
0x15, 0x00, // Logical Minimum (0)
0x26, 0xFF, 0x00, // Logical Maximum (255)
0x75, 0x08, // Report Size (8 bits)
0x95, CUSTOM_HID_EPIN_SIZE, // Report Count (64 fields)
0x81, 0x08, // Input (Data, Variable, Absolute)
// The Output report
0x09, 0x04, // Usage ID - vendor defined
0x15, 0x00, // Logical Minimum (0)
0x26, 0xFF, 0x00, // Logical Maximum (255)
0x75, 0x08, // Report Size (8 bits)
0x95, CUSTOM_HID_EPOUT_SIZE, // Report Count (64 fields)
0x91, 0x08, // Output (Data, Variable, Absolute)
0xC0
};
/* USB CUSTOM_HID device Configuration Descriptor */
__ALIGN_BEGIN const uint8_t const USBD_CUSTOM_HID_CfgDesc[] __ALIGN_END =
{
0x09, /* bLength: Configuration Descriptor size */
USB_DESC_TYPE_CONFIGURATION, /* bDescriptorType: Configuration */
0x29,
/* wTotalLength: Bytes returned */
0x00,
0x01, /*bNumInterfaces: 1 interface*/
0x01, /*bConfigurationValue: Configuration value*/
0x00, /*iConfiguration: Index of string descriptor describing
the configuration*/
0xC0, /*bmAttributes: bus powered */
0x32, /*MaxPower 100 mA: this current is used for detecting Vbus*/
/************** Descriptor of CUSTOM HID interface ****************/
/* 09 */
0x09, /*bLength: Interface Descriptor size*/
USB_DESC_TYPE_INTERFACE,/*bDescriptorType: Interface descriptor type*/
0x00, /*bInterfaceNumber: Number of Interface*/
0x00, /*bAlternateSetting: Alternate setting*/
0x02, /*bNumEndpoints*/
0x03, /*bInterfaceClass: CUSTOM_HID*/
0x00, /*bInterfaceSubClass : 1=BOOT, 0=no boot*/
0x00, /*nInterfaceProtocol : 0=none, 1=keyboard, 2=mouse*/
0, /*iInterface: Index of string descriptor*/
/******************** Descriptor of CUSTOM_HID *************************/
/* 18 */
0x09, /*bLength: CUSTOM_HID Descriptor size*/
CUSTOM_HID_DESCRIPTOR_TYPE, /*bDescriptorType: CUSTOM_HID*/
0x11, /*bCUSTOM_HIDUSTOM_HID: CUSTOM_HID Class Spec release number*/
0x01,
0x00, /*bCountryCode: Hardware target country*/
0x01, /*bNumDescriptors: Number of CUSTOM_HID class descriptors to follow*/
0x22, /*bDescriptorType*/
sizeof(CUSTOM_HID_ReportDesc),/*wItemLength: Total length of Report descriptor*/
0x00,
/******************** Descriptor of Custom HID endpoints ********************/
/* 27 */
0x07, /*bLength: Endpoint Descriptor size*/
USB_DESC_TYPE_ENDPOINT, /*bDescriptorType:*/
CUSTOM_HID_EPIN_ADDR, /*bEndpointAddress: Endpoint Address (IN)*/
0x03, /*bmAttributes: Interrupt endpoint*/
CUSTOM_HID_EPIN_SIZE, /*wMaxPacketSize: 2 Byte max */
0x00,
0x01, /*bInterval: Polling Interval (20 ms)*/
/* 34 */
0x07, /* bLength: Endpoint Descriptor size */
USB_DESC_TYPE_ENDPOINT, /* bDescriptorType: */
CUSTOM_HID_EPOUT_ADDR, /*bEndpointAddress: Endpoint Address (OUT)*/
0x03, /* bmAttributes: Interrupt endpoint */
CUSTOM_HID_EPOUT_SIZE, /* wMaxPacketSize: 2 Bytes max */
0x00,
0x01, /* bInterval: Polling Interval (20 ms) */
/* 41 */
} ;
#endif // HAVE_IO_USB_CDC
/* USB CUSTOM_HID device Configuration Descriptor */
__ALIGN_BEGIN const uint8_t const USBD_CUSTOM_HID_Desc[] __ALIGN_END =
{
/* 18 */
0x09, /*bLength: CUSTOM_HID Descriptor size*/
CUSTOM_HID_DESCRIPTOR_TYPE, /*bDescriptorType: CUSTOM_HID*/
0x11, /*bCUSTOM_HIDUSTOM_HID: CUSTOM_HID Class Spec release number*/
0x01,
0x00, /*bCountryCode: Hardware target country*/
0x01, /*bNumDescriptors: Number of CUSTOM_HID class descriptors to follow*/
0x22, /*bDescriptorType*/
sizeof(CUSTOM_HID_ReportDesc),/*wItemLength: Total length of Report descriptor*/
0x00,
};
/* USB Standard Device Descriptor */
__ALIGN_BEGIN const uint8_t const USBD_CUSTOM_HID_DeviceQualifierDesc[] __ALIGN_END =
{
USB_LEN_DEV_QUALIFIER_DESC,
USB_DESC_TYPE_DEVICE_QUALIFIER,
0x00,
0x02,
0x00,
0x00,
0x00,
0x40,
0x01,
0x00,
};
/* Private variables ---------------------------------------------------------*/
const USBD_DescriptorsTypeDef const HID_Desc = {
USBD_HID_DeviceDescriptor,
USBD_HID_LangIDStrDescriptor,
USBD_HID_ManufacturerStrDescriptor,
USBD_HID_ProductStrDescriptor,
USBD_HID_SerialStrDescriptor,
USBD_HID_ConfigStrDescriptor,
USBD_HID_InterfaceStrDescriptor,
};
/* USB Standard Device Descriptor */
const uint8_t const USBD_DeviceDesc[USB_LEN_DEV_DESC]= {
0x12, /* bLength */
USB_DESC_TYPE_DEVICE, /* bDescriptorType */
0x00, /* bcdUSB */
0x02,
0x00, /* bDeviceClass */
0x00, /* bDeviceSubClass */
0x00, /* bDeviceProtocol */
USB_MAX_EP0_SIZE, /* bMaxPacketSize */
LOBYTE(USBD_VID), /* idVendor */
HIBYTE(USBD_VID), /* idVendor */
LOBYTE(USBD_PID), /* idVendor */
HIBYTE(USBD_PID), /* idVendor */
0x00, /* bcdDevice rel. 2.00 */
0x02,
USBD_IDX_MFC_STR, /* Index of manufacturer string */
USBD_IDX_PRODUCT_STR, /* Index of product string */
USBD_IDX_SERIAL_STR, /* Index of serial number string */
USBD_MAX_NUM_CONFIGURATION /* bNumConfigurations */
}; /* USB_DeviceDescriptor */
USBD_CUSTOM_HID_HandleTypeDef custom_hid_ClassData;
/**
* @brief Returns the device descriptor.
* @param speed: Current device speed
* @param length: Pointer to data length variable
* @retval Pointer to descriptor buffer
*/
uint8_t *USBD_HID_DeviceDescriptor(USBD_SpeedTypeDef speed, uint16_t *length)
{
*length = sizeof(USBD_DeviceDesc);
return (uint8_t*)USBD_DeviceDesc;
}
/**
* @brief Returns the LangID string descriptor.
* @param speed: Current device speed
* @param length: Pointer to data length variable
* @retval Pointer to descriptor buffer
*/
uint8_t *USBD_HID_LangIDStrDescriptor(USBD_SpeedTypeDef speed, uint16_t *length)
{
*length = sizeof(USBD_LangIDDesc);
return (uint8_t*)USBD_LangIDDesc;
}
/**
* @brief Returns the product string descriptor.
* @param speed: Current device speed
* @param length: Pointer to data length variable
* @retval Pointer to descriptor buffer
*/
uint8_t *USBD_HID_ProductStrDescriptor(USBD_SpeedTypeDef speed, uint16_t *length)
{
*length = sizeof(USBD_PRODUCT_FS_STRING);
return USBD_PRODUCT_FS_STRING;
}
/**
* @brief Returns the manufacturer string descriptor.
* @param speed: Current device speed
* @param length: Pointer to data length variable
* @retval Pointer to descriptor buffer
*/
uint8_t *USBD_HID_ManufacturerStrDescriptor(USBD_SpeedTypeDef speed, uint16_t *length)
{
*length = sizeof(USBD_MANUFACTURER_STRING);
return USBD_MANUFACTURER_STRING;
}
/**
* @brief Returns the serial number string descriptor.
* @param speed: Current device speed
* @param length: Pointer to data length variable
* @retval Pointer to descriptor buffer
*/
uint8_t *USBD_HID_SerialStrDescriptor(USBD_SpeedTypeDef speed, uint16_t *length)
{
*length = sizeof(USB_SERIAL_STRING);
return USB_SERIAL_STRING;
}
/**
* @brief Returns the configuration string descriptor.
* @param speed: Current device speed
* @param length: Pointer to data length variable
* @retval Pointer to descriptor buffer
*/
uint8_t *USBD_HID_ConfigStrDescriptor(USBD_SpeedTypeDef speed, uint16_t *length)
{
*length = sizeof(USBD_CONFIGURATION_FS_STRING);
return USBD_CONFIGURATION_FS_STRING;
}
/**
* @brief Returns the interface string descriptor.
* @param speed: Current device speed
* @param length: Pointer to data length variable
* @retval Pointer to descriptor buffer
*/
uint8_t *USBD_HID_InterfaceStrDescriptor(USBD_SpeedTypeDef speed, uint16_t *length)
{
*length = sizeof(USBD_INTERFACE_FS_STRING);
return USBD_INTERFACE_FS_STRING;
}
/**
* @brief Convert Hex 32Bits value into char
* @param value: value to convert
* @param pbuf: pointer to the buffer
* @param len: buffer length
* @retval None
*/
static void IntToUnicode (uint32_t value , uint8_t *pbuf , uint8_t len)
{
uint8_t idx = 0;
for( idx = 0 ; idx < len ; idx ++)
{
if( ((value >> 28)) < 0xA )
{
pbuf[ 2* idx] = (value >> 28) + '0';
}
else
{
pbuf[2* idx] = (value >> 28) + 'A' - 10;
}
value = value << 4;
pbuf[ 2* idx + 1] = 0;
}
}
/**
* @}
*/
/** @defgroup USBD_CUSTOM_HID_Private_Functions
* @{
*/
/**
* @brief USBD_CUSTOM_HID_Init
* Initialize the CUSTOM_HID interface
* @param pdev: device instance
* @param cfgidx: Configuration index
* @retval status
*/
static uint8_t USBD_CUSTOM_HID_Init (USBD_HandleTypeDef *pdev,
uint8_t cfgidx)
{
USBD_CUSTOM_HID_HandleTypeDef* hhid;
/*
USBD_LL_OpenEP(pdev,
0x83,
USBD_EP_TYPE_BULK,
8);
*/
/* Open EP IN */
USBD_LL_OpenEP(pdev,
CUSTOM_HID_EPIN_ADDR,
USBD_EP_TYPE_BULK,
CUSTOM_HID_EPIN_SIZE);
/* Open EP OUT */
USBD_LL_OpenEP(pdev,
CUSTOM_HID_EPOUT_ADDR,
USBD_EP_TYPE_BULK,
CUSTOM_HID_EPOUT_SIZE);
pdev->pClassData = &custom_hid_ClassData; //USBD_malloc(sizeof (USBD_CUSTOM_HID_HandleTypeDef));
if(pdev->pClassData == NULL)
{
return USBD_FAIL;
}
hhid = pdev->pClassData;
hhid->state = CUSTOM_HID_IDLE;
((HIDInit_t)PIC(((USBD_CUSTOM_HID_ItfTypeDef *)pdev->pUserData)->Init))();
/* Prepare Out endpoint to receive 1st packet */
USBD_LL_PrepareReceive(pdev, CUSTOM_HID_EPOUT_ADDR, USBD_CUSTOM_HID_OUTREPORT_BUF_SIZE);
/* garbles the usb com visibly
// transmit a first empty reply on the IN endpoint
USBD_LL_Transmit (pdev,
CUSTOM_HID_EPIN_ADDR,
NULL,
0);
*/
return USBD_OK;
}
/**
* @brief USBD_CUSTOM_HID_Init
* DeInitialize the CUSTOM_HID layer
* @param pdev: device instance
* @param cfgidx: Configuration index
* @retval status
*/
static uint8_t USBD_CUSTOM_HID_DeInit (USBD_HandleTypeDef *pdev,
uint8_t cfgidx)
{
/* Close CUSTOM_HID EP IN */
USBD_LL_CloseEP(pdev,
CUSTOM_HID_EPIN_ADDR);
/* Close CUSTOM_HID EP OUT */
USBD_LL_CloseEP(pdev,
CUSTOM_HID_EPOUT_ADDR);
/* FRee allocated memory */
if(pdev->pClassData != NULL)
{
((HIDDeInit_t)PIC(((USBD_CUSTOM_HID_ItfTypeDef *)pdev->pUserData)->DeInit))();
//USBD_free(pdev->pClassData);
pdev->pClassData = NULL;
}
return USBD_OK;
}
/**
* @brief USBD_CUSTOM_HID_Setup
* Handle the CUSTOM_HID specific requests
* @param pdev: instance
* @param req: usb requests
* @retval status
*/
static uint8_t USBD_CUSTOM_HID_Setup (USBD_HandleTypeDef *pdev,
USBD_SetupReqTypedef *req)
{
uint16_t len = 0;
uint8_t *pbuf = NULL;
USBD_CUSTOM_HID_HandleTypeDef *hhid = pdev->pClassData;
#ifdef HAVE_IO_USB_CDC
switch (req->bmRequest & USB_REQ_TYPE_MASK)
{
case USB_REQ_TYPE_CLASS :
switch (req->bRequest)
{
case 0x20:
USBD_CtlPrepareRx (pdev, hhid->Report_buf, (uint8_t)(req->wLength));
case 0x22:
break;
default:
USBD_CtlError (pdev, req);
return USBD_FAIL;
}
break;
default:
USBD_CtlError (pdev, req);
return USBD_FAIL;
}
#else
switch (req->bmRequest & USB_REQ_TYPE_MASK)
{
case USB_REQ_TYPE_CLASS :
switch (req->bRequest)
{
case CUSTOM_HID_REQ_SET_PROTOCOL:
hhid->Protocol = (uint8_t)(req->wValue);
break;
case CUSTOM_HID_REQ_GET_PROTOCOL:
USBD_CtlSendData (pdev,
(uint8_t *)&hhid->Protocol,
1);
break;
case CUSTOM_HID_REQ_SET_IDLE:
hhid->IdleState = (uint8_t)(req->wValue >> 8);
break;
case CUSTOM_HID_REQ_GET_IDLE:
USBD_CtlSendData (pdev,
(uint8_t *)&hhid->IdleState,
1);
break;
default:
USBD_CtlError (pdev, req);
return USBD_FAIL;
}
break;
case USB_REQ_TYPE_STANDARD:
switch (req->bRequest)
{
case USB_REQ_GET_DESCRIPTOR:
if( req->wValue >> 8 == CUSTOM_HID_REPORT_DESC)
{
len = MIN(sizeof(CUSTOM_HID_ReportDesc) , req->wLength);
pbuf = CUSTOM_HID_ReportDesc;
}
else if( req->wValue >> 8 == CUSTOM_HID_DESCRIPTOR_TYPE)
{
pbuf = USBD_CUSTOM_HID_Desc;
len = MIN(sizeof(USBD_CUSTOM_HID_Desc) , req->wLength);
}
USBD_CtlSendData (pdev,
pbuf,
len);
break;
case USB_REQ_GET_INTERFACE :
USBD_CtlSendData (pdev,
(uint8_t *)&hhid->AltSetting,
1);
break;
case USB_REQ_SET_INTERFACE :
hhid->AltSetting = (uint8_t)(req->wValue);
break;
}
}
#endif // HAVE_IO_USB_CDC
return USBD_OK;
}
/**
* @brief USBD_CUSTOM_HID_SendReport
* Send CUSTOM_HID Report
* @param pdev: device instance
* @param buff: pointer to report
* @retval status
*/
uint8_t USBD_CUSTOM_HID_SendReport (USBD_HandleTypeDef *pdev,
uint8_t *report,
uint16_t len)
{
USBD_CUSTOM_HID_HandleTypeDef *hhid = pdev->pClassData;
if (pdev->dev_state == USBD_STATE_CONFIGURED )
{
/*
if(hhid->state == CUSTOM_HID_IDLE)
{
hhid->state = CUSTOM_HID_BUSY;
*/
USBD_LL_Transmit (pdev,
CUSTOM_HID_EPIN_ADDR,
report,
len);
//}
}
return USBD_OK;
}
/**
* @brief USBD_CUSTOM_HID_GetCfgDesc
* return configuration descriptor
* @param speed : current device speed
* @param length : pointer data length
* @retval pointer to descriptor buffer
*/
static uint8_t *USBD_CUSTOM_HID_GetCfgDesc (uint16_t *length)
{
*length = sizeof (USBD_CUSTOM_HID_CfgDesc);
return USBD_CUSTOM_HID_CfgDesc;
}
/**
* @brief USBD_CUSTOM_HID_DataIn
* handle data IN Stage
* @param pdev: device instance
* @param epnum: endpoint index
* @retval status
*/
static uint8_t USBD_CUSTOM_HID_DataIn (USBD_HandleTypeDef *pdev,
uint8_t epnum)
{
/* Ensure that the FIFO is empty before a new transfer, this condition could
be caused by a new transfer before the end of the previous transfer */
((USBD_CUSTOM_HID_HandleTypeDef *)pdev->pClassData)->state = CUSTOM_HID_IDLE;
return USBD_OK;
}
/**
* @brief USBD_CUSTOM_HID_DataOut
* handle data OUT Stage
* @param pdev: device instance
* @param epnum: endpoint index
* @retval status
*/
static uint8_t USBD_CUSTOM_HID_DataOut (USBD_HandleTypeDef *pdev,
uint8_t epnum, uint8_t* buffer)
{
USBD_CUSTOM_HID_HandleTypeDef *hhid = pdev->pClassData;
USBD_LL_PrepareReceive(pdev, CUSTOM_HID_EPOUT_ADDR , USBD_CUSTOM_HID_OUTREPORT_BUF_SIZE);
((HIDOutEvent_t)PIC(((USBD_CUSTOM_HID_ItfTypeDef *)pdev->pUserData)->OutEvent))(buffer);
return USBD_OK;
}
/**
* @brief USBD_CUSTOM_HID_EP0_RxReady
* Handles control request data.
* @param pdev: device instance
* @retval status
*/
uint8_t USBD_CUSTOM_HID_EP0_RxReady(USBD_HandleTypeDef *pdev)
{
USBD_CUSTOM_HID_HandleTypeDef *hhid = pdev->pClassData;
if (hhid->IsReportAvailable == 1)
{
((HIDOutEvent_t)PIC(((USBD_CUSTOM_HID_ItfTypeDef *)pdev->pUserData)->OutEvent))(NULL);
hhid->IsReportAvailable = 0;
}
return USBD_OK;
}
/**
* @brief DeviceQualifierDescriptor
* return Device Qualifier descriptor
* @param length : pointer data length
* @retval pointer to descriptor buffer
*/
static uint8_t *USBD_CUSTOM_HID_GetDeviceQualifierDesc (uint16_t *length)
{
*length = sizeof (USBD_CUSTOM_HID_DeviceQualifierDesc);
return USBD_CUSTOM_HID_DeviceQualifierDesc;
}
/**
* @brief USBD_CUSTOM_HID_RegisterInterface
* @param pdev: device instance
* @param fops: CUSTOMHID Interface callback
* @retval status
*/
uint8_t USBD_CUSTOM_HID_RegisterInterface (USBD_HandleTypeDef *pdev,
USBD_CUSTOM_HID_ItfTypeDef *fops)
{
uint8_t ret = USBD_FAIL;
if(fops != NULL)
{
pdev->pUserData= fops;
ret = USBD_OK;
}
return ret;
}
/**
* @}
*/
/**
* @}
*/
/**
* @}
*/
/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

View File

@ -0,0 +1,169 @@
/**
******************************************************************************
* @file usbd_conf_template.h
* @author MCD Application Team
* @version V2.4.1
* @date 19-June-2015
* @brief Header file for the usbd_conf_template.c file
******************************************************************************
* @attention
*
* <h2><center>&copy; COPYRIGHT 2015 STMicroelectronics</center></h2>
*
* Licensed under MCD-ST Liberty SW License Agreement V2, (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.st.com/software_license_agreement_liberty_v2
*
* 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.
*
******************************************************************************
*/
/* Define to prevent recursive inclusion -------------------------------------*/
#ifndef __USBD_CONF_TEMPLATE_H
#define __USBD_CONF_TEMPLATE_H
#ifdef __cplusplus
extern "C" {
#endif
/* Includes ------------------------------------------------------------------*/
#include "stm32fxxx.h" /* replace 'stm32xxx' with your HAL driver header filename, ex: stm32f4xx.h */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/** @addtogroup STM32_USB_DEVICE_LIBRARY
* @{
*/
/** @defgroup USBD_CONF
* @brief USB device low level driver configuration file
* @{
*/
/** @defgroup USBD_CONF_Exported_Defines
* @{
*/
#define USBD_MAX_NUM_INTERFACES 1
#define USBD_MAX_NUM_CONFIGURATION 1
#define USBD_MAX_STR_DESC_SIZ 0x100
#define USBD_SUPPORT_USER_STRING 0
#define USBD_SELF_POWERED 1
#define USBD_DEBUG_LEVEL 2
/* MSC Class Config */
#define MSC_MEDIA_PACKET 8192
/* CDC Class Config */
#define USBD_CDC_INTERVAL 2000
/* DFU Class Config */
#define USBD_DFU_MAX_ITF_NUM 1
#define USBD_DFU_XFERS_IZE 1024
/* AUDIO Class Config */
#define USBD_AUDIO_FREQ 22100
/** @defgroup USBD_Exported_Macros
* @{
*/
/* Memory management macros */
#define USBD_malloc malloc
#define USBD_free free
#define USBD_memset memset
#define USBD_memcpy memcpy
/* DEBUG macros */
#if (USBD_DEBUG_LEVEL > 0)
#define USBD_UsrLog(...) printf(__VA_ARGS__);\
printf("\n");
#else
#define USBD_UsrLog(...)
#endif
#if (USBD_DEBUG_LEVEL > 1)
#define USBD_ErrLog(...) printf("ERROR: ") ;\
printf(__VA_ARGS__);\
printf("\n");
#else
#define USBD_ErrLog(...)
#endif
#if (USBD_DEBUG_LEVEL > 2)
#define USBD_DbgLog(...) printf("DEBUG : ") ;\
printf(__VA_ARGS__);\
printf("\n");
#else
#define USBD_DbgLog(...)
#endif
/**
* @}
*/
/**
* @}
*/
/** @defgroup USBD_CONF_Exported_Types
* @{
*/
/**
* @}
*/
/** @defgroup USBD_CONF_Exported_Macros
* @{
*/
/**
* @}
*/
/** @defgroup USBD_CONF_Exported_Variables
* @{
*/
/**
* @}
*/
/** @defgroup USBD_CONF_Exported_FunctionsPrototype
* @{
*/
/**
* @}
*/
#ifdef __cplusplus
}
#endif
#endif /* __USBD_CONF_TEMPLATE_H */
/**
* @}
*/
/**
* @}
*/
/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

View File

@ -0,0 +1,166 @@
/**
******************************************************************************
* @file usbd_core.h
* @author MCD Application Team
* @version V2.4.1
* @date 19-June-2015
* @brief Header file for usbd_core.c file
******************************************************************************
* @attention
*
* <h2><center>&copy; COPYRIGHT 2015 STMicroelectronics</center></h2>
*
* Licensed under MCD-ST Liberty SW License Agreement V2, (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.st.com/software_license_agreement_liberty_v2
*
* 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.
*
******************************************************************************
*/
/* Define to prevent recursive inclusion -------------------------------------*/
#ifndef __USBD_CORE_H
#define __USBD_CORE_H
#ifdef __cplusplus
extern "C" {
#endif
/* Includes ------------------------------------------------------------------*/
#include "usbd_conf.h"
#include "usbd_def.h"
#include "usbd_ioreq.h"
#include "usbd_ctlreq.h"
/** @addtogroup STM32_USB_DEVICE_LIBRARY
* @{
*/
/** @defgroup USBD_CORE
* @brief This file is the Header file for usbd_core.c file
* @{
*/
/** @defgroup USBD_CORE_Exported_Defines
* @{
*/
/**
* @}
*/
/** @defgroup USBD_CORE_Exported_TypesDefinitions
* @{
*/
/**
* @}
*/
/** @defgroup USBD_CORE_Exported_Macros
* @{
*/
/**
* @}
*/
/** @defgroup USBD_CORE_Exported_Variables
* @{
*/
#define USBD_SOF USBD_LL_SOF
/**
* @}
*/
/** @defgroup USBD_CORE_Exported_FunctionsPrototype
* @{
*/
USBD_StatusTypeDef USBD_Init(USBD_HandleTypeDef *pdev, USBD_DescriptorsTypeDef *pdesc, uint8_t id);
USBD_StatusTypeDef USBD_DeInit(USBD_HandleTypeDef *pdev);
USBD_StatusTypeDef USBD_Start (USBD_HandleTypeDef *pdev);
USBD_StatusTypeDef USBD_Stop (USBD_HandleTypeDef *pdev);
USBD_StatusTypeDef USBD_RegisterClass(USBD_HandleTypeDef *pdev, USBD_ClassTypeDef *pclass);
USBD_StatusTypeDef USBD_RunTestMode (USBD_HandleTypeDef *pdev);
USBD_StatusTypeDef USBD_SetClassConfig(USBD_HandleTypeDef *pdev, uint8_t cfgidx);
USBD_StatusTypeDef USBD_ClrClassConfig(USBD_HandleTypeDef *pdev, uint8_t cfgidx);
USBD_StatusTypeDef USBD_LL_SetupStage(USBD_HandleTypeDef *pdev, uint8_t *psetup);
USBD_StatusTypeDef USBD_LL_DataOutStage(USBD_HandleTypeDef *pdev , uint8_t epnum, uint8_t *pdata);
USBD_StatusTypeDef USBD_LL_DataInStage(USBD_HandleTypeDef *pdev , uint8_t epnum, uint8_t *pdata);
USBD_StatusTypeDef USBD_LL_Reset(USBD_HandleTypeDef *pdev);
USBD_StatusTypeDef USBD_LL_SetSpeed(USBD_HandleTypeDef *pdev, USBD_SpeedTypeDef speed);
USBD_StatusTypeDef USBD_LL_Suspend(USBD_HandleTypeDef *pdev);
USBD_StatusTypeDef USBD_LL_Resume(USBD_HandleTypeDef *pdev);
USBD_StatusTypeDef USBD_LL_SOF(USBD_HandleTypeDef *pdev);
USBD_StatusTypeDef USBD_LL_IsoINIncomplete(USBD_HandleTypeDef *pdev, uint8_t epnum);
USBD_StatusTypeDef USBD_LL_IsoOUTIncomplete(USBD_HandleTypeDef *pdev, uint8_t epnum);
USBD_StatusTypeDef USBD_LL_DevConnected(USBD_HandleTypeDef *pdev);
USBD_StatusTypeDef USBD_LL_DevDisconnected(USBD_HandleTypeDef *pdev);
/* USBD Low Level Driver */
USBD_StatusTypeDef USBD_LL_Init (USBD_HandleTypeDef *pdev);
USBD_StatusTypeDef USBD_LL_DeInit (USBD_HandleTypeDef *pdev);
USBD_StatusTypeDef USBD_LL_Start(USBD_HandleTypeDef *pdev);
USBD_StatusTypeDef USBD_LL_Stop (USBD_HandleTypeDef *pdev);
USBD_StatusTypeDef USBD_LL_OpenEP (USBD_HandleTypeDef *pdev,
uint8_t ep_addr,
uint8_t ep_type,
uint16_t ep_mps);
USBD_StatusTypeDef USBD_LL_CloseEP (USBD_HandleTypeDef *pdev, uint8_t ep_addr);
USBD_StatusTypeDef USBD_LL_FlushEP (USBD_HandleTypeDef *pdev, uint8_t ep_addr);
USBD_StatusTypeDef USBD_LL_StallEP (USBD_HandleTypeDef *pdev, uint8_t ep_addr);
USBD_StatusTypeDef USBD_LL_ClearStallEP (USBD_HandleTypeDef *pdev, uint8_t ep_addr);
uint8_t USBD_LL_IsStallEP (USBD_HandleTypeDef *pdev, uint8_t ep_addr);
USBD_StatusTypeDef USBD_LL_SetUSBAddress (USBD_HandleTypeDef *pdev, uint8_t dev_addr);
USBD_StatusTypeDef USBD_LL_Transmit (USBD_HandleTypeDef *pdev,
uint8_t ep_addr,
uint8_t *pbuf,
uint16_t size);
USBD_StatusTypeDef USBD_LL_PrepareReceive(USBD_HandleTypeDef *pdev,
uint8_t ep_addr,
uint16_t size);
uint32_t USBD_LL_GetRxDataSize (USBD_HandleTypeDef *pdev, uint8_t ep_addr);
void USBD_LL_Delay (uint32_t Delay);
/**
* @}
*/
#ifdef __cplusplus
}
#endif
#endif /* __USBD_CORE_H */
/**
* @}
*/
/**
* @}
*/
/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

View File

@ -0,0 +1,113 @@
/**
******************************************************************************
* @file usbd_req.h
* @author MCD Application Team
* @version V2.4.1
* @date 19-June-2015
* @brief Header file for the usbd_req.c file
******************************************************************************
* @attention
*
* <h2><center>&copy; COPYRIGHT 2015 STMicroelectronics</center></h2>
*
* Licensed under MCD-ST Liberty SW License Agreement V2, (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.st.com/software_license_agreement_liberty_v2
*
* 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.
*
******************************************************************************
*/
/* Define to prevent recursive inclusion -------------------------------------*/
#ifndef __USB_REQUEST_H
#define __USB_REQUEST_H
#ifdef __cplusplus
extern "C" {
#endif
/* Includes ------------------------------------------------------------------*/
#include "usbd_def.h"
/** @addtogroup STM32_USB_DEVICE_LIBRARY
* @{
*/
/** @defgroup USBD_REQ
* @brief header file for the usbd_req.c file
* @{
*/
/** @defgroup USBD_REQ_Exported_Defines
* @{
*/
/**
* @}
*/
/** @defgroup USBD_REQ_Exported_Types
* @{
*/
/**
* @}
*/
/** @defgroup USBD_REQ_Exported_Macros
* @{
*/
/**
* @}
*/
/** @defgroup USBD_REQ_Exported_Variables
* @{
*/
/**
* @}
*/
/** @defgroup USBD_REQ_Exported_FunctionsPrototype
* @{
*/
USBD_StatusTypeDef USBD_StdDevReq (USBD_HandleTypeDef *pdev, USBD_SetupReqTypedef *req);
USBD_StatusTypeDef USBD_StdItfReq (USBD_HandleTypeDef *pdev, USBD_SetupReqTypedef *req);
USBD_StatusTypeDef USBD_StdEPReq (USBD_HandleTypeDef *pdev, USBD_SetupReqTypedef *req);
void USBD_CtlError (USBD_HandleTypeDef *pdev, USBD_SetupReqTypedef *req);
void USBD_ParseSetupRequest (USBD_SetupReqTypedef *req, uint8_t *pdata);
void USBD_GetString (uint8_t *desc, uint8_t *unicode, uint16_t *len);
/**
* @}
*/
#ifdef __cplusplus
}
#endif
#endif /* __USB_REQUEST_H */
/**
* @}
*/
/**
* @}
*/
/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

View File

@ -0,0 +1,360 @@
/**
******************************************************************************
* @file usbd_def.h
* @author MCD Application Team
* @version V2.4.1
* @date 19-June-2015
* @brief General defines for the usb device library
******************************************************************************
* @attention
*
* <h2><center>&copy; COPYRIGHT 2015 STMicroelectronics</center></h2>
*
* Licensed under MCD-ST Liberty SW License Agreement V2, (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.st.com/software_license_agreement_liberty_v2
*
* 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.
*
******************************************************************************
*/
/* Define to prevent recursive inclusion -------------------------------------*/
#ifndef __USBD_DEF_H
#define __USBD_DEF_H
#ifdef __cplusplus
extern "C" {
#endif
/* Includes ------------------------------------------------------------------*/
#include "usbd_conf.h"
/** @addtogroup STM32_USBD_DEVICE_LIBRARY
* @{
*/
/** @defgroup USB_DEF
* @brief general defines for the usb device library file
* @{
*/
/** @defgroup USB_DEF_Exported_Defines
* @{
*/
#ifndef NULL
#define NULL 0
#endif
#define USB_LEN_DEV_QUALIFIER_DESC 0x0A
#define USB_LEN_DEV_DESC 0x12
#define USB_LEN_CFG_DESC 0x09
#define USB_LEN_IF_DESC 0x09
#define USB_LEN_EP_DESC 0x07
#define USB_LEN_OTG_DESC 0x03
#define USB_LEN_LANGID_STR_DESC 0x04
#define USB_LEN_OTHER_SPEED_DESC_SIZ 0x09
#define USBD_IDX_LANGID_STR 0x00
#define USBD_IDX_MFC_STR 0x01
#define USBD_IDX_PRODUCT_STR 0x02
#define USBD_IDX_SERIAL_STR 0x03
#define USBD_IDX_CONFIG_STR 0x04
#define USBD_IDX_INTERFACE_STR 0x05
#define USB_REQ_TYPE_STANDARD 0x00
#define USB_REQ_TYPE_CLASS 0x20
#define USB_REQ_TYPE_VENDOR 0x40
#define USB_REQ_TYPE_MASK 0x60
#define USB_REQ_RECIPIENT_DEVICE 0x00
#define USB_REQ_RECIPIENT_INTERFACE 0x01
#define USB_REQ_RECIPIENT_ENDPOINT 0x02
#define USB_REQ_RECIPIENT_MASK 0x03
#define USB_REQ_GET_STATUS 0x00
#define USB_REQ_CLEAR_FEATURE 0x01
#define USB_REQ_SET_FEATURE 0x03
#define USB_REQ_SET_ADDRESS 0x05
#define USB_REQ_GET_DESCRIPTOR 0x06
#define USB_REQ_SET_DESCRIPTOR 0x07
#define USB_REQ_GET_CONFIGURATION 0x08
#define USB_REQ_SET_CONFIGURATION 0x09
#define USB_REQ_GET_INTERFACE 0x0A
#define USB_REQ_SET_INTERFACE 0x0B
#define USB_REQ_SYNCH_FRAME 0x0C
#define USB_DESC_TYPE_DEVICE 1
#define USB_DESC_TYPE_CONFIGURATION 2
#define USB_DESC_TYPE_STRING 3
#define USB_DESC_TYPE_INTERFACE 4
#define USB_DESC_TYPE_ENDPOINT 5
#define USB_DESC_TYPE_DEVICE_QUALIFIER 6
#define USB_DESC_TYPE_OTHER_SPEED_CONFIGURATION 7
#define USB_DESC_TYPE_BOS 0x0F
#define USB_CONFIG_REMOTE_WAKEUP 2
#define USB_CONFIG_SELF_POWERED 1
#define USB_FEATURE_EP_HALT 0
#define USB_FEATURE_REMOTE_WAKEUP 1
#define USB_FEATURE_TEST_MODE 2
#define USB_DEVICE_CAPABITY_TYPE 0x10
#define USB_HS_MAX_PACKET_SIZE 512
#define USB_FS_MAX_PACKET_SIZE 64
#define USB_MAX_EP0_SIZE 64
/* Device Status */
#define USBD_STATE_DEFAULT 1
#define USBD_STATE_ADDRESSED 2
#define USBD_STATE_CONFIGURED 3
#define USBD_STATE_SUSPENDED 4
/* EP0 State */
#define USBD_EP0_IDLE 0
#define USBD_EP0_SETUP 1
#define USBD_EP0_DATA_IN 2
#define USBD_EP0_DATA_OUT 3
#define USBD_EP0_STATUS_IN 4
#define USBD_EP0_STATUS_OUT 5
#define USBD_EP0_STALL 6
#define USBD_EP_TYPE_CTRL 0
#define USBD_EP_TYPE_ISOC 1
#define USBD_EP_TYPE_BULK 2
#define USBD_EP_TYPE_INTR 3
/**
* @}
*/
/** @defgroup USBD_DEF_Exported_TypesDefinitions
* @{
*/
typedef struct usb_setup_req
{
uint8_t bmRequest;
uint8_t bRequest;
uint16_t wValue;
uint16_t wIndex;
uint16_t wLength;
}USBD_SetupReqTypedef;
struct _USBD_HandleTypeDef;
typedef uint8_t (*Init_t) (struct _USBD_HandleTypeDef *pdev , uint8_t cfgidx);
typedef uint8_t (*DeInit_t) (struct _USBD_HandleTypeDef *pdev , uint8_t cfgidx);
/* Control Endpoints*/
typedef uint8_t (*Setup_t) (struct _USBD_HandleTypeDef *pdev , USBD_SetupReqTypedef *req);
typedef uint8_t (*EP0_TxSent_t) (struct _USBD_HandleTypeDef *pdev );
typedef uint8_t (*EP0_RxReady_t) (struct _USBD_HandleTypeDef *pdev );
/* Class Specific Endpoints*/
typedef uint8_t (*DataIn_t) (struct _USBD_HandleTypeDef *pdev , uint8_t epnum);
typedef uint8_t (*DataOut_t) (struct _USBD_HandleTypeDef *pdev , uint8_t epnum, uint8_t* pData);
typedef uint8_t (*SOF_t) (struct _USBD_HandleTypeDef *pdev);
typedef uint8_t (*IsoINIncomplete_t) (struct _USBD_HandleTypeDef *pdev , uint8_t epnum);
typedef uint8_t (*IsoOUTIncomplete_t) (struct _USBD_HandleTypeDef *pdev , uint8_t epnum);
typedef uint8_t *(*GetHSConfigDescriptor_t)(uint16_t *length);
typedef uint8_t *(*GetFSConfigDescriptor_t)(uint16_t *length);
typedef uint8_t *(*GetOtherSpeedConfigDescriptor_t)(uint16_t *length);
typedef uint8_t *(*GetDeviceQualifierDescriptor_t)(uint16_t *length);
#if (USBD_SUPPORT_USER_STRING == 1)
typedef uint8_t *(*GetUsrStrDescriptor_t)(struct _USBD_HandleTypeDef *pdev ,uint8_t index, uint16_t *length);
#endif
typedef struct _Device_cb
{
Init_t Init;
DeInit_t DeInit;
/* Control Endpoints*/
Setup_t Setup;
EP0_TxSent_t EP0_TxSent;
EP0_RxReady_t EP0_RxReady;
/* Class Specific Endpoints*/
DataIn_t DataIn;
DataOut_t DataOut;
SOF_t SOF;
IsoINIncomplete_t IsoINIncomplete;
IsoOUTIncomplete_t IsoOUTIncomplete;
GetHSConfigDescriptor_t GetHSConfigDescriptor;
GetFSConfigDescriptor_t GetFSConfigDescriptor;
GetOtherSpeedConfigDescriptor_t GetOtherSpeedConfigDescriptor;
GetDeviceQualifierDescriptor_t GetDeviceQualifierDescriptor;
#if (USBD_SUPPORT_USER_STRING == 1)
GetUsrStrDescriptor_t GetUsrStrDescriptor;
#endif
} USBD_ClassTypeDef;
/* Following USB Device Speed */
typedef enum
{
USBD_SPEED_HIGH = 0,
USBD_SPEED_FULL = 1,
USBD_SPEED_LOW = 2,
}USBD_SpeedTypeDef;
/* Following USB Device status */
typedef enum {
USBD_OK = 0,
USBD_BUSY,
USBD_FAIL,
}USBD_StatusTypeDef;
typedef uint8_t *(*GetDeviceDescriptor_t)( USBD_SpeedTypeDef speed , uint16_t *length);
typedef uint8_t *(*GetLangIDStrDescriptor_t)( USBD_SpeedTypeDef speed , uint16_t *length);
typedef uint8_t *(*GetManufacturerStrDescriptor_t)( USBD_SpeedTypeDef speed , uint16_t *length);
typedef uint8_t *(*GetProductStrDescriptor_t)( USBD_SpeedTypeDef speed , uint16_t *length);
typedef uint8_t *(*GetSerialStrDescriptor_t)( USBD_SpeedTypeDef speed , uint16_t *length);
typedef uint8_t *(*GetConfigurationStrDescriptor_t)( USBD_SpeedTypeDef speed , uint16_t *length);
typedef uint8_t *(*GetInterfaceStrDescriptor_t)( USBD_SpeedTypeDef speed , uint16_t *length);
typedef uint8_t *(*GetBOSDescriptor_t)( USBD_SpeedTypeDef speed , uint16_t *length);
/* USB Device descriptors structure */
typedef struct
{
GetDeviceDescriptor_t GetDeviceDescriptor;
GetLangIDStrDescriptor_t GetLangIDStrDescriptor;
GetManufacturerStrDescriptor_t GetManufacturerStrDescriptor;
GetProductStrDescriptor_t GetProductStrDescriptor;
GetSerialStrDescriptor_t GetSerialStrDescriptor;
GetConfigurationStrDescriptor_t GetConfigurationStrDescriptor;
GetInterfaceStrDescriptor_t GetInterfaceStrDescriptor;
#if (USBD_LPM_ENABLED == 1)
GetBOSDescriptor_t GetBOSDescriptor;
#endif
} USBD_DescriptorsTypeDef;
/* USB Device handle structure */
typedef struct
{
uint32_t status;
uint32_t total_length;
uint32_t rem_length;
uint32_t maxpacket;
} USBD_EndpointTypeDef;
/* USB Device handle structure */
typedef struct _USBD_HandleTypeDef
{
uint8_t id;
uint32_t dev_config;
uint32_t dev_default_config;
uint32_t dev_config_status;
USBD_SpeedTypeDef dev_speed;
USBD_EndpointTypeDef ep_in[15];
USBD_EndpointTypeDef ep_out[15];
uint32_t ep0_state;
uint32_t ep0_data_len;
uint8_t dev_state;
uint8_t dev_old_state;
uint8_t dev_address;
uint8_t dev_connection_status;
uint8_t dev_test_mode;
uint32_t dev_remote_wakeup;
USBD_SetupReqTypedef request;
USBD_DescriptorsTypeDef *pDesc;
USBD_ClassTypeDef *pClass;
void *pClassData;
void *pUserData;
void *pData;
} USBD_HandleTypeDef;
/**
* @}
*/
/** @defgroup USBD_DEF_Exported_Macros
* @{
*/
#define SWAPBYTE(addr) (((uint16_t)(*((uint8_t *)(addr)))) + \
(((uint16_t)(*(((uint8_t *)(addr)) + 1))) << 8))
#define LOBYTE(x) ((uint8_t)(x & 0x00FF))
#define HIBYTE(x) ((uint8_t)((x & 0xFF00) >>8))
#define MIN(a, b) (((a) < (b)) ? (a) : (b))
#define MAX(a, b) (((a) > (b)) ? (a) : (b))
#if defined ( __GNUC__ )
#ifndef __weak
#define __weak __attribute__((weak))
#endif /* __weak */
#ifndef __packed
#define __packed __attribute__((__packed__))
#endif /* __packed */
#endif /* __GNUC__ */
/* In HS mode and when the DMA is used, all variables and data structures dealing
with the DMA during the transaction process should be 4-bytes aligned */
#if defined (__GNUC__) /* GNU Compiler */
#define __ALIGN_END __attribute__ ((aligned (4)))
#define __ALIGN_BEGIN
#else
#define __ALIGN_END
#if defined (__CC_ARM) /* ARM Compiler */
#define __ALIGN_BEGIN __align(4)
#elif defined (__ICCARM__) /* IAR Compiler */
#define __ALIGN_BEGIN
#elif defined (__TASKING__) /* TASKING Compiler */
#define __ALIGN_BEGIN __align(4)
#endif /* __CC_ARM */
#endif /* __GNUC__ */
/**
* @}
*/
/** @defgroup USBD_DEF_Exported_Variables
* @{
*/
/**
* @}
*/
/** @defgroup USBD_DEF_Exported_FunctionsPrototype
* @{
*/
/**
* @}
*/
#ifdef __cplusplus
}
#endif
#endif /* __USBD_DEF_H */
/**
* @}
*/
/**
* @}
*/
/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

View File

@ -0,0 +1,128 @@
/**
******************************************************************************
* @file usbd_ioreq.h
* @author MCD Application Team
* @version V2.4.1
* @date 19-June-2015
* @brief Header file for the usbd_ioreq.c file
******************************************************************************
* @attention
*
* <h2><center>&copy; COPYRIGHT 2015 STMicroelectronics</center></h2>
*
* Licensed under MCD-ST Liberty SW License Agreement V2, (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.st.com/software_license_agreement_liberty_v2
*
* 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.
*
******************************************************************************
*/
/* Define to prevent recursive inclusion -------------------------------------*/
#ifndef __USBD_IOREQ_H
#define __USBD_IOREQ_H
#ifdef __cplusplus
extern "C" {
#endif
/* Includes ------------------------------------------------------------------*/
#include "usbd_def.h"
#include "usbd_core.h"
/** @addtogroup STM32_USB_DEVICE_LIBRARY
* @{
*/
/** @defgroup USBD_IOREQ
* @brief header file for the usbd_ioreq.c file
* @{
*/
/** @defgroup USBD_IOREQ_Exported_Defines
* @{
*/
/**
* @}
*/
/** @defgroup USBD_IOREQ_Exported_Types
* @{
*/
/**
* @}
*/
/** @defgroup USBD_IOREQ_Exported_Macros
* @{
*/
/**
* @}
*/
/** @defgroup USBD_IOREQ_Exported_Variables
* @{
*/
/**
* @}
*/
/** @defgroup USBD_IOREQ_Exported_FunctionsPrototype
* @{
*/
USBD_StatusTypeDef USBD_CtlSendData (USBD_HandleTypeDef *pdev,
uint8_t *buf,
uint16_t len);
USBD_StatusTypeDef USBD_CtlContinueSendData (USBD_HandleTypeDef *pdev,
uint8_t *pbuf,
uint16_t len);
USBD_StatusTypeDef USBD_CtlPrepareRx (USBD_HandleTypeDef *pdev,
uint8_t *pbuf,
uint16_t len);
USBD_StatusTypeDef USBD_CtlContinueRx (USBD_HandleTypeDef *pdev,
uint8_t *pbuf,
uint16_t len);
USBD_StatusTypeDef USBD_CtlSendStatus (USBD_HandleTypeDef *pdev);
USBD_StatusTypeDef USBD_CtlReceiveStatus (USBD_HandleTypeDef *pdev);
uint16_t USBD_GetRxCount (USBD_HandleTypeDef *pdev ,
uint8_t epnum);
/**
* @}
*/
#ifdef __cplusplus
}
#endif
#endif /* __USBD_IOREQ_H */
/**
* @}
*/
/**
* @}
*/
/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

View File

@ -0,0 +1,212 @@
/**
******************************************************************************
* @file usbd_conf_template.c
* @author MCD Application Team
* @version V2.4.1
* @date 19-June-2015
* @brief USB Device configuration and interface file
* This template should be copied to the user folder, renamed and customized
* following user needs.
******************************************************************************
* @attention
*
* <h2><center>&copy; COPYRIGHT 2015 STMicroelectronics</center></h2>
*
* Licensed under MCD-ST Liberty SW License Agreement V2, (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.st.com/software_license_agreement_liberty_v2
*
* 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.
*
******************************************************************************
*/
/* Includes ------------------------------------------------------------------*/
#include "usbd_core.h"
/* Private typedef -----------------------------------------------------------*/
/* Private define ------------------------------------------------------------*/
/* Private macro -------------------------------------------------------------*/
/* Private variables ---------------------------------------------------------*/
/* Private function prototypes -----------------------------------------------*/
/* Private functions ---------------------------------------------------------*/
/**
* @brief Initializes the Low Level portion of the Device driver.
* @param pdev: Device handle
* @retval USBD Status
*/
USBD_StatusTypeDef USBD_LL_Init(USBD_HandleTypeDef *pdev)
{
return USBD_OK;
}
/**
* @brief De-Initializes the Low Level portion of the Device driver.
* @param pdev: Device handle
* @retval USBD Status
*/
USBD_StatusTypeDef USBD_LL_DeInit(USBD_HandleTypeDef *pdev)
{
return USBD_OK;
}
/**
* @brief Starts the Low Level portion of the Device driver.
* @param pdev: Device handle
* @retval USBD Status
*/
USBD_StatusTypeDef USBD_LL_Start(USBD_HandleTypeDef *pdev)
{
return USBD_OK;
}
/**
* @brief Stops the Low Level portion of the Device driver.
* @param pdev: Device handle
* @retval USBD Status
*/
USBD_StatusTypeDef USBD_LL_Stop(USBD_HandleTypeDef *pdev)
{
return USBD_OK;
}
/**
* @brief Opens an endpoint of the Low Level Driver.
* @param pdev: Device handle
* @param ep_addr: Endpoint Number
* @param ep_type: Endpoint Type
* @param ep_mps: Endpoint Max Packet Size
* @retval USBD Status
*/
USBD_StatusTypeDef USBD_LL_OpenEP(USBD_HandleTypeDef *pdev,
uint8_t ep_addr,
uint8_t ep_type,
uint16_t ep_mps)
{
return USBD_OK;
}
/**
* @brief Closes an endpoint of the Low Level Driver.
* @param pdev: Device handle
* @param ep_addr: Endpoint Number
* @retval USBD Status
*/
USBD_StatusTypeDef USBD_LL_CloseEP(USBD_HandleTypeDef *pdev, uint8_t ep_addr)
{
return USBD_OK;
}
/**
* @brief Flushes an endpoint of the Low Level Driver.
* @param pdev: Device handle
* @param ep_addr: Endpoint Number
* @retval USBD Status
*/
USBD_StatusTypeDef USBD_LL_FlushEP(USBD_HandleTypeDef *pdev, uint8_t ep_addr)
{
return USBD_OK;
}
/**
* @brief Sets a Stall condition on an endpoint of the Low Level Driver.
* @param pdev: Device handle
* @param ep_addr: Endpoint Number
* @retval USBD Status
*/
USBD_StatusTypeDef USBD_LL_StallEP(USBD_HandleTypeDef *pdev, uint8_t ep_addr)
{
return USBD_OK;
}
/**
* @brief Clears a Stall condition on an endpoint of the Low Level Driver.
* @param pdev: Device handle
* @param ep_addr: Endpoint Number
* @retval USBD Status
*/
USBD_StatusTypeDef USBD_LL_ClearStallEP(USBD_HandleTypeDef *pdev, uint8_t ep_addr)
{
return USBD_OK;
}
/**
* @brief Returns Stall condition.
* @param pdev: Device handle
* @param ep_addr: Endpoint Number
* @retval Stall (1: Yes, 0: No)
*/
uint8_t USBD_LL_IsStallEP(USBD_HandleTypeDef *pdev, uint8_t ep_addr)
{
return 0;
}
/**
* @brief Assigns a USB address to the device.
* @param pdev: Device handle
* @param ep_addr: Endpoint Number
* @retval USBD Status
*/
USBD_StatusTypeDef USBD_LL_SetUSBAddress(USBD_HandleTypeDef *pdev, uint8_t dev_addr)
{
return USBD_OK;
}
/**
* @brief Transmits data over an endpoint.
* @param pdev: Device handle
* @param ep_addr: Endpoint Number
* @param pbuf: Pointer to data to be sent
* @param size: Data size
* @retval USBD Status
*/
USBD_StatusTypeDef USBD_LL_Transmit(USBD_HandleTypeDef *pdev,
uint8_t ep_addr,
uint8_t *pbuf,
uint16_t size)
{
return USBD_OK;
}
/**
* @brief Prepares an endpoint for reception.
* @param pdev: Device handle
* @param ep_addr: Endpoint Number
* @param pbuf: Pointer to data to be received
* @param size: Data size
* @retval USBD Status
*/
USBD_StatusTypeDef USBD_LL_PrepareReceive(USBD_HandleTypeDef *pdev,
uint8_t ep_addr,
uint8_t *pbuf,
uint16_t size)
{
return USBD_OK;
}
/**
* @brief Returns the last transferred packet size.
* @param pdev: Device handle
* @param ep_addr: Endpoint Number
* @retval Recived Data Size
*/
uint32_t USBD_LL_GetRxDataSize(USBD_HandleTypeDef *pdev, uint8_t ep_addr)
{
return 0;
}
/**
* @brief Delays routine for the USB Device Library.
* @param Delay: Delay in ms
* @retval None
*/
void USBD_LL_Delay(uint32_t Delay)
{
}
/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

View File

@ -0,0 +1,575 @@
/**
******************************************************************************
* @file usbd_core.c
* @author MCD Application Team
* @version V2.4.1
* @date 19-June-2015
* @brief This file provides all the USBD core functions.
******************************************************************************
* @attention
*
* <h2><center>&copy; COPYRIGHT 2015 STMicroelectronics</center></h2>
*
* Licensed under MCD-ST Liberty SW License Agreement V2, (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.st.com/software_license_agreement_liberty_v2
*
* 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.
*
******************************************************************************
*/
/* Includes ------------------------------------------------------------------*/
#include "usbd_core.h"
#include "os.h"
/** @addtogroup STM32_USBD_DEVICE_LIBRARY
* @{
*/
/** @defgroup USBD_CORE
* @brief usbd core module
* @{
*/
/** @defgroup USBD_CORE_Private_TypesDefinitions
* @{
*/
/**
* @}
*/
/** @defgroup USBD_CORE_Private_Defines
* @{
*/
/**
* @}
*/
/** @defgroup USBD_CORE_Private_Macros
* @{
*/
/**
* @}
*/
/** @defgroup USBD_CORE_Private_FunctionPrototypes
* @{
*/
/**
* @}
*/
/** @defgroup USBD_CORE_Private_Variables
* @{
*/
/**
* @}
*/
/** @defgroup USBD_CORE_Private_Functions
* @{
*/
/**
* @brief USBD_Init
* Initializes the device stack and load the class driver
* @param pdev: device instance
* @param pdesc: Descriptor structure address
* @param id: Low level core index
* @retval None
*/
USBD_StatusTypeDef USBD_Init(USBD_HandleTypeDef *pdev, USBD_DescriptorsTypeDef *pdesc, uint8_t id)
{
/* Check whether the USB Host handle is valid */
if(pdev == NULL)
{
USBD_ErrLog("Invalid Device handle");
return USBD_FAIL;
}
memset(pdev, 0, sizeof(pdev));
/* Unlink previous class*/
if(pdev->pClass != NULL)
{
pdev->pClass = NULL;
}
/* Assign USBD Descriptors */
if(pdesc != NULL)
{
pdev->pDesc = pdesc;
}
/* Set Device initial State */
pdev->dev_state = USBD_STATE_DEFAULT;
pdev->id = id;
/* Initialize low level driver */
USBD_LL_Init(pdev);
return USBD_OK;
}
/**
* @brief USBD_DeInit
* Re-Initialize th device library
* @param pdev: device instance
* @retval status: status
*/
USBD_StatusTypeDef USBD_DeInit(USBD_HandleTypeDef *pdev)
{
/* Set Default State */
pdev->dev_state = USBD_STATE_DEFAULT;
/* Free Class Resources */
if(pdev->pClass != NULL) {
((DeInit_t)PIC(pdev->pClass->DeInit))(pdev, pdev->dev_config);
}
/* Stop the low level driver */
USBD_LL_Stop(pdev);
/* Initialize low level driver */
USBD_LL_DeInit(pdev);
return USBD_OK;
}
/**
* @brief USBD_RegisterClass
* Link class driver to Device Core.
* @param pDevice : Device Handle
* @param pclass: Class handle
* @retval USBD Status
*/
USBD_StatusTypeDef USBD_RegisterClass(USBD_HandleTypeDef *pdev, USBD_ClassTypeDef *pclass)
{
USBD_StatusTypeDef status = USBD_OK;
if(pclass != 0)
{
/* link the class to the USB Device handle */
pdev->pClass = pclass;
status = USBD_OK;
}
else
{
USBD_ErrLog("Invalid Class handle");
status = USBD_FAIL;
}
return status;
}
/**
* @brief USBD_Start
* Start the USB Device Core.
* @param pdev: Device Handle
* @retval USBD Status
*/
USBD_StatusTypeDef USBD_Start (USBD_HandleTypeDef *pdev)
{
/* Start the low level driver */
USBD_LL_Start(pdev);
return USBD_OK;
}
/**
* @brief USBD_Stop
* Stop the USB Device Core.
* @param pdev: Device Handle
* @retval USBD Status
*/
USBD_StatusTypeDef USBD_Stop (USBD_HandleTypeDef *pdev)
{
/* Free Class Resources */
if(pdev->pClass != NULL) {
((DeInit_t)PIC(pdev->pClass->DeInit))(pdev, pdev->dev_config);
}
/* Stop the low level driver */
USBD_LL_Stop(pdev);
return USBD_OK;
}
/**
* @brief USBD_RunTestMode
* Launch test mode process
* @param pdev: device instance
* @retval status
*/
USBD_StatusTypeDef USBD_RunTestMode (USBD_HandleTypeDef *pdev)
{
return USBD_OK;
}
/**
* @brief USBD_SetClassConfig
* Configure device and start the interface
* @param pdev: device instance
* @param cfgidx: configuration index
* @retval status
*/
USBD_StatusTypeDef USBD_SetClassConfig(USBD_HandleTypeDef *pdev, uint8_t cfgidx)
{
USBD_StatusTypeDef ret = USBD_FAIL;
if(pdev->pClass != NULL)
{
/* Set configuration and Start the Class*/
if(((Init_t)PIC(pdev->pClass->Init))(pdev, cfgidx) == 0)
{
ret = USBD_OK;
}
}
return ret;
}
/**
* @brief USBD_ClrClassConfig
* Clear current configuration
* @param pdev: device instance
* @param cfgidx: configuration index
* @retval status: USBD_StatusTypeDef
*/
USBD_StatusTypeDef USBD_ClrClassConfig(USBD_HandleTypeDef *pdev, uint8_t cfgidx)
{
/* Clear configuration and De-initialize the Class process*/
if(pdev->pClass != NULL) {
((DeInit_t)PIC(pdev->pClass->DeInit))(pdev, cfgidx);
}
return USBD_OK;
}
/**
* @brief USBD_SetupStage
* Handle the setup stage
* @param pdev: device instance
* @retval status
*/
USBD_StatusTypeDef USBD_LL_SetupStage(USBD_HandleTypeDef *pdev, uint8_t *psetup)
{
USBD_ParseSetupRequest(&pdev->request, psetup);
pdev->ep0_state = USBD_EP0_SETUP;
pdev->ep0_data_len = pdev->request.wLength;
switch (pdev->request.bmRequest & 0x1F)
{
case USB_REQ_RECIPIENT_DEVICE:
USBD_StdDevReq (pdev, &pdev->request);
break;
case USB_REQ_RECIPIENT_INTERFACE:
USBD_StdItfReq(pdev, &pdev->request);
break;
case USB_REQ_RECIPIENT_ENDPOINT:
USBD_StdEPReq(pdev, &pdev->request);
break;
default:
USBD_LL_StallEP(pdev , pdev->request.bmRequest & 0x80);
break;
}
return USBD_OK;
}
/**
* @brief USBD_DataOutStage
* Handle data OUT stage
* @param pdev: device instance
* @param epnum: endpoint index
* @retval status
*/
USBD_StatusTypeDef USBD_LL_DataOutStage(USBD_HandleTypeDef *pdev , uint8_t epnum, uint8_t *pdata)
{
USBD_EndpointTypeDef *pep;
if(epnum == 0)
{
pep = &pdev->ep_out[0];
if ( pdev->ep0_state == USBD_EP0_DATA_OUT)
{
if(pep->rem_length > pep->maxpacket)
{
pep->rem_length -= pep->maxpacket;
USBD_CtlContinueRx (pdev,
pdata,
MIN(pep->rem_length ,pep->maxpacket));
}
else
{
if((pdev->pClass->EP0_RxReady != NULL)&&
(pdev->dev_state == USBD_STATE_CONFIGURED))
{
((EP0_RxReady_t)PIC(pdev->pClass->EP0_RxReady))(pdev);
}
USBD_CtlSendStatus(pdev);
}
}
}
else if((pdev->pClass->DataOut != NULL)&&
(pdev->dev_state == USBD_STATE_CONFIGURED))
{
((DataOut_t)PIC(pdev->pClass->DataOut))(pdev, epnum, pdata);
}
return USBD_OK;
}
/**
* @brief USBD_DataInStage
* Handle data in stage
* @param pdev: device instance
* @param epnum: endpoint index
* @retval status
*/
USBD_StatusTypeDef USBD_LL_DataInStage(USBD_HandleTypeDef *pdev ,uint8_t epnum, uint8_t *pdata)
{
USBD_EndpointTypeDef *pep;
if(epnum == 0)
{
pep = &pdev->ep_in[0];
if ( pdev->ep0_state == USBD_EP0_DATA_IN)
{
if(pep->rem_length > pep->maxpacket)
{
pep->rem_length -= pep->maxpacket;
USBD_CtlContinueSendData (pdev,
pdata,
pep->rem_length);
/* Prepare endpoint for premature end of transfer */
USBD_LL_PrepareReceive (pdev,
0,
0);
}
else
{ /* last packet is MPS multiple, so send ZLP packet */
if((pep->total_length % pep->maxpacket == 0) &&
(pep->total_length >= pep->maxpacket) &&
(pep->total_length < pdev->ep0_data_len ))
{
USBD_CtlContinueSendData(pdev , NULL, 0);
pdev->ep0_data_len = 0;
/* Prepare endpoint for premature end of transfer */
USBD_LL_PrepareReceive (pdev,
0,
0);
}
else
{
if(pdev->pClass != NULL && (pdev->pClass->EP0_TxSent != NULL)&&
(pdev->dev_state == USBD_STATE_CONFIGURED))
{
((EP0_TxSent_t)PIC(pdev->pClass->EP0_TxSent))(pdev);
}
USBD_CtlReceiveStatus(pdev);
}
}
}
if (pdev->dev_test_mode == 1)
{
USBD_RunTestMode(pdev);
pdev->dev_test_mode = 0;
}
}
else if(pdev->pClass != NULL && (pdev->pClass->DataIn != NULL)&&
(pdev->dev_state == USBD_STATE_CONFIGURED))
{
((DataIn_t)PIC(pdev->pClass->DataIn))(pdev, epnum);
}
return USBD_OK;
}
/**
* @brief USBD_LL_Reset
* Handle Reset event
* @param pdev: device instance
* @retval status
*/
USBD_StatusTypeDef USBD_LL_Reset(USBD_HandleTypeDef *pdev)
{
#if 0 // fastpath, done on the L4 for MOAR SPEED
/* Open EP0 OUT */
USBD_LL_OpenEP(pdev,
0x00,
USBD_EP_TYPE_CTRL,
USB_MAX_EP0_SIZE);
/* Open EP0 IN */
USBD_LL_OpenEP(pdev,
0x80,
USBD_EP_TYPE_CTRL,
USB_MAX_EP0_SIZE);
#endif // 0
pdev->ep_out[0].maxpacket = USB_MAX_EP0_SIZE;
pdev->ep_in[0].maxpacket = USB_MAX_EP0_SIZE;
/* Upon Reset call user call back */
pdev->dev_state = USBD_STATE_DEFAULT;
if (pdev->pClass) {
((DeInit_t)PIC(pdev->pClass->DeInit))(pdev, pdev->dev_config);
}
return USBD_OK;
}
/**
* @brief USBD_LL_Reset
* Handle Reset event
* @param pdev: device instance
* @retval status
*/
USBD_StatusTypeDef USBD_LL_SetSpeed(USBD_HandleTypeDef *pdev, USBD_SpeedTypeDef speed)
{
pdev->dev_speed = speed;
return USBD_OK;
}
/**
* @brief USBD_Suspend
* Handle Suspend event
* @param pdev: device instance
* @retval status
*/
USBD_StatusTypeDef USBD_LL_Suspend(USBD_HandleTypeDef *pdev)
{
pdev->dev_old_state = pdev->dev_state;
pdev->dev_state = USBD_STATE_SUSPENDED;
return USBD_OK;
}
/**
* @brief USBD_Resume
* Handle Resume event
* @param pdev: device instance
* @retval status
*/
USBD_StatusTypeDef USBD_LL_Resume(USBD_HandleTypeDef *pdev)
{
pdev->dev_state = pdev->dev_old_state;
return USBD_OK;
}
/**
* @brief USBD_SOF
* Handle SOF event
* @param pdev: device instance
* @retval status
*/
USBD_StatusTypeDef USBD_LL_SOF(USBD_HandleTypeDef *pdev)
{
if(pdev->dev_state == USBD_STATE_CONFIGURED)
{
if(pdev->pClass->SOF != NULL)
{
((SOF_t)PIC(pdev->pClass->SOF))(pdev);
}
}
return USBD_OK;
}
/**
* @brief USBD_IsoINIncomplete
* Handle iso in incomplete event
* @param pdev: device instance
* @retval status
*/
USBD_StatusTypeDef USBD_LL_IsoINIncomplete(USBD_HandleTypeDef *pdev, uint8_t epnum)
{
return USBD_OK;
}
/**
* @brief USBD_IsoOUTIncomplete
* Handle iso out incomplete event
* @param pdev: device instance
* @retval status
*/
USBD_StatusTypeDef USBD_LL_IsoOUTIncomplete(USBD_HandleTypeDef *pdev, uint8_t epnum)
{
return USBD_OK;
}
/**
* @brief USBD_DevConnected
* Handle device connection event
* @param pdev: device instance
* @retval status
*/
USBD_StatusTypeDef USBD_LL_DevConnected(USBD_HandleTypeDef *pdev)
{
return USBD_OK;
}
/**
* @brief USBD_DevDisconnected
* Handle device disconnection event
* @param pdev: device instance
* @retval status
*/
USBD_StatusTypeDef USBD_LL_DevDisconnected(USBD_HandleTypeDef *pdev)
{
/* Free Class Resources */
pdev->dev_state = USBD_STATE_DEFAULT;
// done upon reset // ((DeInit_t)PIC(pdev->pClass->DeInit))(pdev, pdev->dev_config);
return USBD_OK;
}
/**
* @}
*/
/**
* @}
*/
/**
* @}
*/
/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

View File

@ -0,0 +1,787 @@
/**
******************************************************************************
* @file usbd_req.c
* @author MCD Application Team
* @version V2.4.1
* @date 19-June-2015
* @brief This file provides the standard USB requests following chapter 9.
******************************************************************************
* @attention
*
* <h2><center>&copy; COPYRIGHT 2015 STMicroelectronics</center></h2>
*
* Licensed under MCD-ST Liberty SW License Agreement V2, (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.st.com/software_license_agreement_liberty_v2
*
* 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.
*
******************************************************************************
*/
/* Includes ------------------------------------------------------------------*/
#include "usbd_ctlreq.h"
#include "usbd_ioreq.h"
#include "os.h"
/** @addtogroup STM32_USBD_STATE_DEVICE_LIBRARY
* @{
*/
/** @defgroup USBD_REQ
* @brief USB standard requests module
* @{
*/
/** @defgroup USBD_REQ_Private_TypesDefinitions
* @{
*/
/**
* @}
*/
/** @defgroup USBD_REQ_Private_Defines
* @{
*/
/**
* @}
*/
/** @defgroup USBD_REQ_Private_Macros
* @{
*/
/**
* @}
*/
/** @defgroup USBD_REQ_Private_Variables
* @{
*/
/**
* @}
*/
/** @defgroup USBD_REQ_Private_FunctionPrototypes
* @{
*/
static void USBD_GetDescriptor(USBD_HandleTypeDef *pdev ,
USBD_SetupReqTypedef *req);
static void USBD_SetAddress(USBD_HandleTypeDef *pdev ,
USBD_SetupReqTypedef *req);
static void USBD_SetConfig(USBD_HandleTypeDef *pdev ,
USBD_SetupReqTypedef *req);
static void USBD_GetConfig(USBD_HandleTypeDef *pdev ,
USBD_SetupReqTypedef *req);
static void USBD_GetStatus(USBD_HandleTypeDef *pdev ,
USBD_SetupReqTypedef *req);
static void USBD_SetFeature(USBD_HandleTypeDef *pdev ,
USBD_SetupReqTypedef *req);
static void USBD_ClrFeature(USBD_HandleTypeDef *pdev ,
USBD_SetupReqTypedef *req);
static uint8_t USBD_GetLen(uint8_t *buf);
/**
* @}
*/
/** @defgroup USBD_REQ_Private_Functions
* @{
*/
/**
* @brief USBD_StdDevReq
* Handle standard usb device requests
* @param pdev: device instance
* @param req: usb request
* @retval status
*/
USBD_StatusTypeDef USBD_StdDevReq (USBD_HandleTypeDef *pdev , USBD_SetupReqTypedef *req)
{
USBD_StatusTypeDef ret = USBD_OK;
switch (req->bRequest)
{
case USB_REQ_GET_DESCRIPTOR:
USBD_GetDescriptor (pdev, req) ;
break;
case USB_REQ_SET_ADDRESS:
USBD_SetAddress(pdev, req);
break;
case USB_REQ_SET_CONFIGURATION:
USBD_SetConfig (pdev , req);
break;
case USB_REQ_GET_CONFIGURATION:
USBD_GetConfig (pdev , req);
break;
case USB_REQ_GET_STATUS:
USBD_GetStatus (pdev , req);
break;
case USB_REQ_SET_FEATURE:
USBD_SetFeature (pdev , req);
break;
case USB_REQ_CLEAR_FEATURE:
USBD_ClrFeature (pdev , req);
break;
default:
USBD_CtlError(pdev , req);
break;
}
return ret;
}
/**
* @brief USBD_StdItfReq
* Handle standard usb interface requests
* @param pdev: device instance
* @param req: usb request
* @retval status
*/
USBD_StatusTypeDef USBD_StdItfReq (USBD_HandleTypeDef *pdev , USBD_SetupReqTypedef *req)
{
USBD_StatusTypeDef ret = USBD_OK;
switch (pdev->dev_state)
{
case USBD_STATE_CONFIGURED:
if (LOBYTE(req->wIndex) <= USBD_MAX_NUM_INTERFACES)
{
((Setup_t)PIC(pdev->pClass->Setup)) (pdev, req);
if((req->wLength == 0)&& (ret == USBD_OK))
{
USBD_CtlSendStatus(pdev);
}
}
else
{
USBD_CtlError(pdev , req);
}
break;
default:
USBD_CtlError(pdev , req);
break;
}
return USBD_OK;
}
/**
* @brief USBD_StdEPReq
* Handle standard usb endpoint requests
* @param pdev: device instance
* @param req: usb request
* @retval status
*/
USBD_StatusTypeDef USBD_StdEPReq (USBD_HandleTypeDef *pdev , USBD_SetupReqTypedef *req)
{
uint8_t ep_addr;
USBD_StatusTypeDef ret = USBD_OK;
USBD_EndpointTypeDef *pep;
ep_addr = LOBYTE(req->wIndex);
/* Check if it is a class request */
if ((req->bmRequest & 0x60) == 0x20)
{
((Setup_t)PIC(pdev->pClass->Setup)) (pdev, req);
return USBD_OK;
}
switch (req->bRequest)
{
case USB_REQ_SET_FEATURE :
switch (pdev->dev_state)
{
case USBD_STATE_ADDRESSED:
if ((ep_addr != 0x00) && (ep_addr != 0x80))
{
USBD_LL_StallEP(pdev , ep_addr);
}
break;
case USBD_STATE_CONFIGURED:
if (req->wValue == USB_FEATURE_EP_HALT)
{
if ((ep_addr != 0x00) && (ep_addr != 0x80))
{
USBD_LL_StallEP(pdev , ep_addr);
}
}
((Setup_t)PIC(pdev->pClass->Setup)) (pdev, req);
USBD_CtlSendStatus(pdev);
break;
default:
USBD_CtlError(pdev , req);
break;
}
break;
case USB_REQ_CLEAR_FEATURE :
switch (pdev->dev_state)
{
case USBD_STATE_ADDRESSED:
if ((ep_addr != 0x00) && (ep_addr != 0x80))
{
USBD_LL_StallEP(pdev , ep_addr);
}
break;
case USBD_STATE_CONFIGURED:
if (req->wValue == USB_FEATURE_EP_HALT)
{
if ((ep_addr & 0x7F) != 0x00)
{
USBD_LL_ClearStallEP(pdev , ep_addr);
((Setup_t)PIC(pdev->pClass->Setup)) (pdev, req);
}
USBD_CtlSendStatus(pdev);
}
break;
default:
USBD_CtlError(pdev , req);
break;
}
break;
case USB_REQ_GET_STATUS:
switch (pdev->dev_state)
{
case USBD_STATE_ADDRESSED:
if ((ep_addr & 0x7F) != 0x00)
{
USBD_LL_StallEP(pdev , ep_addr);
}
break;
case USBD_STATE_CONFIGURED:
pep = ((ep_addr & 0x80) == 0x80) ? &pdev->ep_in[ep_addr & 0x7F]:\
&pdev->ep_out[ep_addr & 0x7F];
if(USBD_LL_IsStallEP(pdev, ep_addr))
{
pep->status = 0x0001;
}
else
{
pep->status = 0x0000;
}
USBD_CtlSendData (pdev,
(uint8_t *)&pep->status,
2);
break;
default:
USBD_CtlError(pdev , req);
break;
}
break;
default:
break;
}
return ret;
}
/**
* @brief USBD_GetDescriptor
* Handle Get Descriptor requests
* @param pdev: device instance
* @param req: usb request
* @retval status
*/
static void USBD_GetDescriptor(USBD_HandleTypeDef *pdev ,
USBD_SetupReqTypedef *req)
{
uint16_t len;
uint8_t *pbuf;
switch (req->wValue >> 8)
{
#if (USBD_LPM_ENABLED == 1)
case USB_DESC_TYPE_BOS:
pbuf = ((GetBOSDescriptor_t)PIC(pdev->pDesc->GetBOSDescriptor))(pdev->dev_speed, &len);
break;
#endif
case USB_DESC_TYPE_DEVICE:
pbuf = ((GetDeviceDescriptor_t)PIC(pdev->pDesc->GetDeviceDescriptor))(pdev->dev_speed, &len);
break;
case USB_DESC_TYPE_CONFIGURATION:
if(pdev->dev_speed == USBD_SPEED_HIGH )
{
pbuf = (uint8_t *)((GetHSConfigDescriptor_t)PIC(pdev->pClass->GetHSConfigDescriptor))(&len);
//pbuf[1] = USB_DESC_TYPE_CONFIGURATION; CONST BUFFER KTHX
}
else
{
pbuf = (uint8_t *)((GetFSConfigDescriptor_t)PIC(pdev->pClass->GetFSConfigDescriptor))(&len);
//pbuf[1] = USB_DESC_TYPE_CONFIGURATION; CONST BUFFER KTHX
}
break;
case USB_DESC_TYPE_STRING:
switch ((uint8_t)(req->wValue))
{
case USBD_IDX_LANGID_STR:
pbuf = ((GetLangIDStrDescriptor_t)PIC(pdev->pDesc->GetLangIDStrDescriptor))(pdev->dev_speed, &len);
break;
case USBD_IDX_MFC_STR:
pbuf = ((GetManufacturerStrDescriptor_t)PIC(pdev->pDesc->GetManufacturerStrDescriptor))(pdev->dev_speed, &len);
break;
case USBD_IDX_PRODUCT_STR:
pbuf = ((GetProductStrDescriptor_t)PIC(pdev->pDesc->GetProductStrDescriptor))(pdev->dev_speed, &len);
break;
case USBD_IDX_SERIAL_STR:
pbuf = ((GetSerialStrDescriptor_t)PIC(pdev->pDesc->GetSerialStrDescriptor))(pdev->dev_speed, &len);
break;
case USBD_IDX_CONFIG_STR:
pbuf = ((GetConfigurationStrDescriptor_t)PIC(pdev->pDesc->GetConfigurationStrDescriptor))(pdev->dev_speed, &len);
break;
case USBD_IDX_INTERFACE_STR:
pbuf = ((GetInterfaceStrDescriptor_t)PIC(pdev->pDesc->GetInterfaceStrDescriptor))(pdev->dev_speed, &len);
break;
default:
#if (USBD_SUPPORT_USER_STRING == 1)
pbuf = ((GetUsrStrDescriptor_t)PIC(pdev->pClass->GetUsrStrDescriptor))(pdev, (req->wValue) , &len);
break;
#else
USBD_CtlError(pdev , req);
return;
#endif
}
break;
case USB_DESC_TYPE_DEVICE_QUALIFIER:
if(pdev->dev_speed == USBD_SPEED_HIGH )
{
pbuf = (uint8_t *)((GetDeviceQualifierDescriptor_t)PIC(pdev->pClass->GetDeviceQualifierDescriptor))(&len);
break;
}
else
{
USBD_CtlError(pdev , req);
return;
}
case USB_DESC_TYPE_OTHER_SPEED_CONFIGURATION:
if(pdev->dev_speed == USBD_SPEED_HIGH )
{
pbuf = (uint8_t *)((GetOtherSpeedConfigDescriptor_t)PIC(pdev->pClass->GetOtherSpeedConfigDescriptor))(&len);
// pbuf[1] = USB_DESC_TYPE_OTHER_SPEED_CONFIGURATION; CONST BUFFER KTHX
break;
}
else
{
USBD_CtlError(pdev , req);
return;
}
default:
USBD_CtlError(pdev , req);
return;
}
if((len != 0)&& (req->wLength != 0))
{
len = MIN(len , req->wLength);
// prepare abort if host does not read the whole data
USBD_CtlReceiveStatus(pdev);
// start transfer
USBD_CtlSendData (pdev,
pbuf,
len);
}
}
/**
* @brief USBD_SetAddress
* Set device address
* @param pdev: device instance
* @param req: usb request
* @retval status
*/
static void USBD_SetAddress(USBD_HandleTypeDef *pdev ,
USBD_SetupReqTypedef *req)
{
uint8_t dev_addr;
if ((req->wIndex == 0) && (req->wLength == 0))
{
dev_addr = (uint8_t)(req->wValue) & 0x7F;
if (pdev->dev_state == USBD_STATE_CONFIGURED)
{
USBD_CtlError(pdev , req);
}
else
{
pdev->dev_address = dev_addr;
USBD_LL_SetUSBAddress(pdev, dev_addr);
USBD_CtlSendStatus(pdev);
if (dev_addr != 0)
{
pdev->dev_state = USBD_STATE_ADDRESSED;
}
else
{
pdev->dev_state = USBD_STATE_DEFAULT;
}
}
}
else
{
USBD_CtlError(pdev , req);
}
}
/**
* @brief USBD_SetConfig
* Handle Set device configuration request
* @param pdev: device instance
* @param req: usb request
* @retval status
*/
static void USBD_SetConfig(USBD_HandleTypeDef *pdev ,
USBD_SetupReqTypedef *req)
{
static uint8_t cfgidx;
cfgidx = (uint8_t)(req->wValue);
if (cfgidx > USBD_MAX_NUM_CONFIGURATION )
{
USBD_CtlError(pdev , req);
}
else
{
switch (pdev->dev_state)
{
case USBD_STATE_ADDRESSED:
if (cfgidx)
{
pdev->dev_config = cfgidx;
pdev->dev_state = USBD_STATE_CONFIGURED;
if(USBD_SetClassConfig(pdev , cfgidx) == USBD_FAIL)
{
USBD_CtlError(pdev , req);
return;
}
USBD_CtlSendStatus(pdev);
}
else
{
USBD_CtlSendStatus(pdev);
}
break;
case USBD_STATE_CONFIGURED:
if (cfgidx == 0)
{
pdev->dev_state = USBD_STATE_ADDRESSED;
pdev->dev_config = cfgidx;
USBD_ClrClassConfig(pdev , cfgidx);
USBD_CtlSendStatus(pdev);
}
else if (cfgidx != pdev->dev_config)
{
/* Clear old configuration */
USBD_ClrClassConfig(pdev , pdev->dev_config);
/* set new configuration */
pdev->dev_config = cfgidx;
if(USBD_SetClassConfig(pdev , cfgidx) == USBD_FAIL)
{
USBD_CtlError(pdev , req);
return;
}
USBD_CtlSendStatus(pdev);
}
else
{
USBD_CtlSendStatus(pdev);
}
break;
default:
USBD_CtlError(pdev , req);
break;
}
}
}
/**
* @brief USBD_GetConfig
* Handle Get device configuration request
* @param pdev: device instance
* @param req: usb request
* @retval status
*/
static void USBD_GetConfig(USBD_HandleTypeDef *pdev ,
USBD_SetupReqTypedef *req)
{
if (req->wLength != 1)
{
USBD_CtlError(pdev , req);
}
else
{
switch (pdev->dev_state )
{
case USBD_STATE_ADDRESSED:
pdev->dev_default_config = 0;
USBD_CtlSendData (pdev,
(uint8_t *)&pdev->dev_default_config,
1);
break;
case USBD_STATE_CONFIGURED:
USBD_CtlSendData (pdev,
(uint8_t *)&pdev->dev_config,
1);
break;
default:
USBD_CtlError(pdev , req);
break;
}
}
}
/**
* @brief USBD_GetStatus
* Handle Get Status request
* @param pdev: device instance
* @param req: usb request
* @retval status
*/
static void USBD_GetStatus(USBD_HandleTypeDef *pdev ,
USBD_SetupReqTypedef *req)
{
switch (pdev->dev_state)
{
case USBD_STATE_ADDRESSED:
case USBD_STATE_CONFIGURED:
#if ( USBD_SELF_POWERED == 1)
pdev->dev_config_status = USB_CONFIG_SELF_POWERED;
#else
pdev->dev_config_status = 0;
#endif
if (pdev->dev_remote_wakeup)
{
pdev->dev_config_status |= USB_CONFIG_REMOTE_WAKEUP;
}
USBD_CtlSendData (pdev,
(uint8_t *)& pdev->dev_config_status,
2);
break;
default :
USBD_CtlError(pdev , req);
break;
}
}
/**
* @brief USBD_SetFeature
* Handle Set device feature request
* @param pdev: device instance
* @param req: usb request
* @retval status
*/
static void USBD_SetFeature(USBD_HandleTypeDef *pdev ,
USBD_SetupReqTypedef *req)
{
if (req->wValue == USB_FEATURE_REMOTE_WAKEUP)
{
pdev->dev_remote_wakeup = 1;
((Setup_t)PIC(pdev->pClass->Setup)) (pdev, req);
USBD_CtlSendStatus(pdev);
}
}
/**
* @brief USBD_ClrFeature
* Handle clear device feature request
* @param pdev: device instance
* @param req: usb request
* @retval status
*/
static void USBD_ClrFeature(USBD_HandleTypeDef *pdev ,
USBD_SetupReqTypedef *req)
{
switch (pdev->dev_state)
{
case USBD_STATE_ADDRESSED:
case USBD_STATE_CONFIGURED:
if (req->wValue == USB_FEATURE_REMOTE_WAKEUP)
{
pdev->dev_remote_wakeup = 0;
((Setup_t)PIC(pdev->pClass->Setup)) (pdev, req);
USBD_CtlSendStatus(pdev);
}
break;
default :
USBD_CtlError(pdev , req);
break;
}
}
/**
* @brief USBD_ParseSetupRequest
* Copy buffer into setup structure
* @param pdev: device instance
* @param req: usb request
* @retval None
*/
void USBD_ParseSetupRequest(USBD_SetupReqTypedef *req, uint8_t *pdata)
{
req->bmRequest = *(uint8_t *) (pdata);
req->bRequest = *(uint8_t *) (pdata + 1);
req->wValue = SWAPBYTE (pdata + 2);
req->wIndex = SWAPBYTE (pdata + 4);
req->wLength = SWAPBYTE (pdata + 6);
}
/**
* @brief USBD_CtlError
* Handle USB low level Error
* @param pdev: device instance
* @param req: usb request
* @retval None
*/
void USBD_CtlError( USBD_HandleTypeDef *pdev ,
USBD_SetupReqTypedef *req)
{
USBD_LL_StallEP(pdev , 0x80);
USBD_LL_StallEP(pdev , 0);
}
/**
* @brief USBD_GetString
* Convert Ascii string into unicode one
* @param desc : descriptor buffer
* @param unicode : Formatted string buffer (unicode)
* @param len : descriptor length
* @retval None
*/
void USBD_GetString(uint8_t *desc, uint8_t *unicode, uint16_t *len)
{
uint8_t idx = 0;
if (desc != NULL)
{
*len = USBD_GetLen(desc) * 2 + 2;
unicode[idx++] = *len;
unicode[idx++] = USB_DESC_TYPE_STRING;
while (*desc != '\0')
{
unicode[idx++] = *desc++;
unicode[idx++] = 0x00;
}
}
}
/**
* @brief USBD_GetLen
* return the string length
* @param buf : pointer to the ascii string buffer
* @retval string length
*/
static uint8_t USBD_GetLen(uint8_t *buf)
{
uint8_t len = 0;
while (*buf != '\0')
{
len++;
buf++;
}
return len;
}
/**
* @}
*/
/**
* @}
*/
/**
* @}
*/
/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

View File

@ -0,0 +1,233 @@
/**
******************************************************************************
* @file usbd_ioreq.c
* @author MCD Application Team
* @version V2.4.1
* @date 19-June-2015
* @brief This file provides the IO requests APIs for control endpoints.
******************************************************************************
* @attention
*
* <h2><center>&copy; COPYRIGHT 2015 STMicroelectronics</center></h2>
*
* Licensed under MCD-ST Liberty SW License Agreement V2, (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.st.com/software_license_agreement_liberty_v2
*
* 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.
*
******************************************************************************
*/
/* Includes ------------------------------------------------------------------*/
#include "usbd_ioreq.h"
/** @addtogroup STM32_USB_DEVICE_LIBRARY
* @{
*/
/** @defgroup USBD_IOREQ
* @brief control I/O requests module
* @{
*/
/** @defgroup USBD_IOREQ_Private_TypesDefinitions
* @{
*/
/**
* @}
*/
/** @defgroup USBD_IOREQ_Private_Defines
* @{
*/
/**
* @}
*/
/** @defgroup USBD_IOREQ_Private_Macros
* @{
*/
/**
* @}
*/
/** @defgroup USBD_IOREQ_Private_Variables
* @{
*/
/**
* @}
*/
/** @defgroup USBD_IOREQ_Private_FunctionPrototypes
* @{
*/
/**
* @}
*/
/** @defgroup USBD_IOREQ_Private_Functions
* @{
*/
/**
* @brief USBD_CtlSendData
* send data on the ctl pipe
* @param pdev: device instance
* @param buff: pointer to data buffer
* @param len: length of data to be sent
* @retval status
*/
USBD_StatusTypeDef USBD_CtlSendData (USBD_HandleTypeDef *pdev,
uint8_t *pbuf,
uint16_t len)
{
/* Set EP0 State */
pdev->ep0_state = USBD_EP0_DATA_IN;
pdev->ep_in[0].total_length = len;
pdev->ep_in[0].rem_length = len;
/* Start the transfer */
USBD_LL_Transmit (pdev, 0x00, pbuf, len);
return USBD_OK;
}
/**
* @brief USBD_CtlContinueSendData
* continue sending data on the ctl pipe
* @param pdev: device instance
* @param buff: pointer to data buffer
* @param len: length of data to be sent
* @retval status
*/
USBD_StatusTypeDef USBD_CtlContinueSendData (USBD_HandleTypeDef *pdev,
uint8_t *pbuf,
uint16_t len)
{
/* Start the next transfer */
USBD_LL_Transmit (pdev, 0x00, pbuf, len);
return USBD_OK;
}
/**
* @brief USBD_CtlPrepareRx
* receive data on the ctl pipe
* @param pdev: device instance
* @param buff: pointer to data buffer
* @param len: length of data to be received
* @retval status
*/
USBD_StatusTypeDef USBD_CtlPrepareRx (USBD_HandleTypeDef *pdev,
uint8_t *pbuf,
uint16_t len)
{
/* Set EP0 State */
pdev->ep0_state = USBD_EP0_DATA_OUT;
pdev->ep_out[0].total_length = len;
pdev->ep_out[0].rem_length = len;
/* Start the transfer */
USBD_LL_PrepareReceive (pdev,
0,
len);
return USBD_OK;
}
/**
* @brief USBD_CtlContinueRx
* continue receive data on the ctl pipe
* @param pdev: device instance
* @param buff: pointer to data buffer
* @param len: length of data to be received
* @retval status
*/
USBD_StatusTypeDef USBD_CtlContinueRx (USBD_HandleTypeDef *pdev,
uint8_t *pbuf,
uint16_t len)
{
USBD_LL_PrepareReceive (pdev,
0,
len);
return USBD_OK;
}
/**
* @brief USBD_CtlSendStatus
* send zero lzngth packet on the ctl pipe
* @param pdev: device instance
* @retval status
*/
USBD_StatusTypeDef USBD_CtlSendStatus (USBD_HandleTypeDef *pdev)
{
/* Set EP0 State */
pdev->ep0_state = USBD_EP0_STATUS_IN;
/* Start the transfer */
USBD_LL_Transmit (pdev, 0x00, NULL, 0);
return USBD_OK;
}
/**
* @brief USBD_CtlReceiveStatus
* receive zero lzngth packet on the ctl pipe
* @param pdev: device instance
* @retval status
*/
USBD_StatusTypeDef USBD_CtlReceiveStatus (USBD_HandleTypeDef *pdev)
{
/* Set EP0 State */
pdev->ep0_state = USBD_EP0_STATUS_OUT;
/* Start the transfer */
USBD_LL_PrepareReceive ( pdev,
0,
0);
return USBD_OK;
}
/**
* @brief USBD_GetRxCount
* returns the received data length
* @param pdev: device instance
* @param ep_addr: endpoint address
* @retval Rx Data blength
*/
uint16_t USBD_GetRxCount (USBD_HandleTypeDef *pdev , uint8_t ep_addr)
{
return USBD_LL_GetRxDataSize(pdev, ep_addr);
}
/**
* @}
*/
/**
* @}
*/
/**
* @}
*/
/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

File diff suppressed because it is too large Load Diff

596
src_usb/usbd_conf.c Normal file
View File

@ -0,0 +1,596 @@
/**
******************************************************************************
* @file : usbd_conf.c
* @brief : This file implements the board support package for the USB device library
******************************************************************************
*
* COPYRIGHT(c) 2015 STMicroelectronics
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* 3. Neither the name of STMicroelectronics nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
******************************************************************************
*/
/* Includes ------------------------------------------------------------------*/
#include "usbd_def.h"
#include "usbd_core.h"
#include "os_io_seproxyhal.h"
//#include "usbd_hid.h"
/* Private typedef -----------------------------------------------------------*/
/* Private define ------------------------------------------------------------*/
/* Private macro -------------------------------------------------------------*/
/* Private variables ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */
/* USER CODE END 0 */
/* Exported function prototypes -----------------------------------------------*/
extern USBD_StatusTypeDef USBD_LL_BatteryCharging(USBD_HandleTypeDef *pdev);
/* Private function prototypes -----------------------------------------------*/
/* Private functions ---------------------------------------------------------*/
//void HAL_PCDEx_SetConnectionState(PCD_HandleTypeDef *hpcd, uint8_t state);
/*******************************************************************************
LL Driver Callbacks (PCD USB Device Library)
*******************************************************************************/
#if 0
/**
* @brief Setup Stage callback
* @param hpcd: PCD handle
* @retval None
*/
void HAL_PCD_SetupStageCallback(PCD_HandleTypeDef *hpcd)
{
USBD_LL_SetupStage(hpcd->pData, (uint8_t *)hpcd->Setup);
}
/**
* @brief Data Out Stage callback.
* @param hpcd: PCD handle
* @param epnum: Endpoint Number
* @retval None
*/
void HAL_PCD_DataOutStageCallback(PCD_HandleTypeDef *hpcd, uint8_t epnum)
{
USBD_LL_DataOutStage(hpcd->pData, epnum, hpcd->OUT_ep[epnum].xfer_buff);
}
/**
* @brief Data In Stage callback..
* @param hpcd: PCD handle
* @param epnum: Endpoint Number
* @retval None
*/
void HAL_PCD_DataInStageCallback(PCD_HandleTypeDef *hpcd, uint8_t epnum)
{
USBD_LL_DataInStage(hpcd->pData, epnum, hpcd->IN_ep[epnum].xfer_buff);
}
/**
* @brief SOF callback.
* @param hpcd: PCD handle
* @retval None
*/
void HAL_PCD_SOFCallback(PCD_HandleTypeDef *hpcd)
{
USBD_LL_SOF(hpcd->pData);
}
/**
* @brief Reset callback.
* @param hpcd: PCD handle
* @retval None
*/
void HAL_PCD_ResetCallback(PCD_HandleTypeDef *hpcd)
{
USBD_SpeedTypeDef speed = USBD_SPEED_FULL;
/*Set USB Current Speed*/
switch (hpcd->Init.speed)
{
case PCD_SPEED_FULL:
speed = USBD_SPEED_FULL;
break;
default:
speed = USBD_SPEED_FULL;
break;
}
USBD_LL_SetSpeed(hpcd->pData, speed);
/*Reset Device*/
USBD_LL_Reset(hpcd->pData);
}
/**
* @brief Suspend callback.
* When Low power mode is enabled the debug cannot be used (IAR, Keil doesn't support it)
* @param hpcd: PCD handle
* @retval None
*/
void HAL_PCD_SuspendCallback(PCD_HandleTypeDef *hpcd)
{
USBD_LL_Suspend(hpcd->pData);
}
/**
* @brief Resume callback.
* When Low power mode is enabled the debug cannot be used (IAR, Keil doesn't support it)
* @param hpcd: PCD handle
* @retval None
*/
void HAL_PCD_ResumeCallback(PCD_HandleTypeDef *hpcd)
{
USBD_LL_Resume(hpcd->pData);
}
/**
* @brief ISOOUTIncomplete callback.
* @param hpcd: PCD handle
* @param epnum: Endpoint Number
* @retval None
*/
void HAL_PCD_ISOOUTIncompleteCallback(PCD_HandleTypeDef *hpcd, uint8_t epnum)
{
USBD_LL_IsoOUTIncomplete(hpcd->pData, epnum);
}
/**
* @brief ISOINIncomplete callback.
* @param hpcd: PCD handle
* @param epnum: Endpoint Number
* @retval None
*/
void HAL_PCD_ISOINIncompleteCallback(PCD_HandleTypeDef *hpcd, uint8_t epnum)
{
USBD_LL_IsoINIncomplete(hpcd->pData, epnum);
}
/**
* @brief ConnectCallback callback.
* @param hpcd: PCD handle
* @retval None
*/
void HAL_PCD_ConnectCallback(PCD_HandleTypeDef *hpcd)
{
USBD_LL_DevConnected(hpcd->pData);
}
/**
* @brief Disconnect callback.
* @param hpcd: PCD handle
* @retval None
*/
void HAL_PCD_DisconnectCallback(PCD_HandleTypeDef *hpcd)
{
USBD_LL_DevDisconnected(hpcd->pData);
}
#endif
/*******************************************************************************
LL Driver Interface (USB Device Library --> PCD)
*******************************************************************************/
unsigned int ep_in_stall;
unsigned int ep_out_stall;
/**
* @brief Initializes the Low Level portion of the Device driver.
* @param pdev: Device handle
* @retval USBD Status
*/
USBD_StatusTypeDef USBD_LL_Init (USBD_HandleTypeDef *pdev)
{
ep_in_stall = 0;
ep_out_stall = 0;
return USBD_OK;
}
/**
* @brief De-Initializes the Low Level portion of the Device driver.
* @param pdev: Device handle
* @retval USBD Status
*/
USBD_StatusTypeDef USBD_LL_DeInit (USBD_HandleTypeDef *pdev)
{
return USBD_OK;
}
/**
* @brief Starts the Low Level portion of the Device driver.
* @param pdev: Device handle
* @retval USBD Status
*/
USBD_StatusTypeDef USBD_LL_Start(USBD_HandleTypeDef *pdev)
{
uint8_t buffer[5];
// reset address
buffer[0] = SEPROXYHAL_TAG_USB_CONFIG;
buffer[1] = 0;
buffer[2] = 2;
buffer[3] = SEPROXYHAL_TAG_USB_CONFIG_ADDR;
buffer[4] = 0;
io_seproxyhal_spi_send(buffer, 5);
// start usb operation
buffer[0] = SEPROXYHAL_TAG_USB_CONFIG;
buffer[1] = 0;
buffer[2] = 1;
buffer[3] = SEPROXYHAL_TAG_USB_CONFIG_CONNECT;
io_seproxyhal_spi_send(buffer, 4);
return USBD_OK;
}
/**
* @brief Stops the Low Level portion of the Device driver.
* @param pdev: Device handle
* @retval USBD Status
*/
USBD_StatusTypeDef USBD_LL_Stop (USBD_HandleTypeDef *pdev)
{
uint8_t buffer[4];
buffer[0] = SEPROXYHAL_TAG_USB_CONFIG;
buffer[1] = 0;
buffer[2] = 1;
buffer[3] = SEPROXYHAL_TAG_USB_CONFIG_DISCONNECT;
io_seproxyhal_spi_send(buffer, 4);
return USBD_OK;
}
/**
* @brief Opens an endpoint of the Low Level Driver.
* @param pdev: Device handle
* @param ep_addr: Endpoint Number
* @param ep_type: Endpoint Type
* @param ep_mps: Endpoint Max Packet Size
* @retval USBD Status
*/
USBD_StatusTypeDef USBD_LL_OpenEP (USBD_HandleTypeDef *pdev,
uint8_t ep_addr,
uint8_t ep_type,
uint16_t ep_mps)
{
uint8_t buffer[8];
ep_in_stall = 0;
ep_out_stall = 0;
buffer[0] = SEPROXYHAL_TAG_USB_CONFIG;
buffer[1] = 0;
buffer[2] = 5;
buffer[3] = SEPROXYHAL_TAG_USB_CONFIG_ENDPOINTS;
buffer[4] = 1;
buffer[5] = ep_addr;
buffer[6] = 0;
switch(ep_type) {
case USBD_EP_TYPE_CTRL:
buffer[6] = SEPROXYHAL_TAG_USB_CONFIG_TYPE_CONTROL;
break;
case USBD_EP_TYPE_ISOC:
buffer[6] = SEPROXYHAL_TAG_USB_CONFIG_TYPE_ISOCHRONOUS;
break;
case USBD_EP_TYPE_BULK:
buffer[6] = SEPROXYHAL_TAG_USB_CONFIG_TYPE_BULK;
break;
case USBD_EP_TYPE_INTR:
buffer[6] = SEPROXYHAL_TAG_USB_CONFIG_TYPE_INTERRUPT;
break;
}
buffer[7] = ep_mps;
io_seproxyhal_spi_send(buffer, 8);
return USBD_OK;
}
/**
* @brief Closes an endpoint of the Low Level Driver.
* @param pdev: Device handle
* @param ep_addr: Endpoint Number
* @retval USBD Status
*/
USBD_StatusTypeDef USBD_LL_CloseEP (USBD_HandleTypeDef *pdev, uint8_t ep_addr)
{
uint8_t buffer[8];
buffer[0] = SEPROXYHAL_TAG_USB_CONFIG;
buffer[1] = 0;
buffer[2] = 5;
buffer[3] = SEPROXYHAL_TAG_USB_CONFIG_ENDPOINTS;
buffer[4] = 1;
buffer[5] = ep_addr;
buffer[6] = SEPROXYHAL_TAG_USB_CONFIG_TYPE_DISABLED;
buffer[7] = 0;
io_seproxyhal_spi_send(buffer, 8);
return USBD_OK;
}
/**
* @brief Flushes an endpoint of the Low Level Driver.
* @param pdev: Device handle
* @param ep_addr: Endpoint Number
* @retval USBD Status
*/
USBD_StatusTypeDef USBD_LL_FlushEP (USBD_HandleTypeDef *pdev, uint8_t ep_addr)
{
//HAL_PCD_EP_Flush(pdev->pData, ep_addr);
return USBD_OK;
}
/**
* @brief Sets a Stall condition on an endpoint of the Low Level Driver.
* @param pdev: Device handle
* @param ep_addr: Endpoint Number
* @retval USBD Status
*/
USBD_StatusTypeDef USBD_LL_StallEP (USBD_HandleTypeDef *pdev, uint8_t ep_addr)
{
uint8_t buffer[6];
buffer[0] = SEPROXYHAL_TAG_USB_EP_PREPARE;
buffer[1] = 0;
buffer[2] = 3;
buffer[3] = ep_addr;
buffer[4] = SEPROXYHAL_TAG_USB_EP_PREPARE_DIR_STALL;
buffer[5] = 0;
io_seproxyhal_spi_send(buffer, 6);
if (ep_addr & 0x80) {
ep_in_stall |= (1<<(ep_addr&0x7F));
}
else {
ep_out_stall |= (1<<(ep_addr&0x7F));
}
return USBD_OK;
}
/**
* @brief Clears a Stall condition on an endpoint of the Low Level Driver.
* @param pdev: Device handle
* @param ep_addr: Endpoint Number
* @retval USBD Status
*/
USBD_StatusTypeDef USBD_LL_ClearStallEP (USBD_HandleTypeDef *pdev, uint8_t ep_addr)
{
uint8_t buffer[6];
buffer[0] = SEPROXYHAL_TAG_USB_EP_PREPARE;
buffer[1] = 0;
buffer[2] = 3;
buffer[3] = ep_addr;
buffer[4] = SEPROXYHAL_TAG_USB_EP_PREPARE_DIR_UNSTALL;
buffer[5] = 0;
io_seproxyhal_spi_send(buffer, 6);
if (ep_addr & 0x80) {
ep_in_stall &= ~(1<<(ep_addr&0x7F));
}
else {
ep_out_stall &= ~(1<<(ep_addr&0x7F));
}
return USBD_OK;
}
/**
* @brief Returns Stall condition.
* @param pdev: Device handle
* @param ep_addr: Endpoint Number
* @retval Stall (1: Yes, 0: No)
*/
uint8_t USBD_LL_IsStallEP (USBD_HandleTypeDef *pdev, uint8_t ep_addr)
{
if((ep_addr & 0x80) == 0x80)
{
return ep_in_stall & (1<<(ep_addr&0x7F));
}
else
{
return ep_out_stall & (1<<(ep_addr&0x7F));
}
}
/**
* @brief Assigns a USB address to the device.
* @param pdev: Device handle
* @param ep_addr: Endpoint Number
* @retval USBD Status
*/
USBD_StatusTypeDef USBD_LL_SetUSBAddress (USBD_HandleTypeDef *pdev, uint8_t dev_addr)
{
uint8_t buffer[5];
buffer[0] = SEPROXYHAL_TAG_USB_CONFIG;
buffer[1] = 0;
buffer[2] = 2;
buffer[3] = SEPROXYHAL_TAG_USB_CONFIG_ADDR;
buffer[4] = dev_addr;
io_seproxyhal_spi_send(buffer, 5);
return USBD_OK;
}
/**
* @brief Transmits data over an endpoint.
* @param pdev: Device handle
* @param ep_addr: Endpoint Number
* @param pbuf: Pointer to data to be sent
* @param size: Data size
* @retval USBD Status
*/
USBD_StatusTypeDef USBD_LL_Transmit (USBD_HandleTypeDef *pdev,
uint8_t ep_addr,
uint8_t *pbuf,
uint16_t size)
{
uint8_t buffer[6];
buffer[0] = SEPROXYHAL_TAG_USB_EP_PREPARE;
buffer[1] = (3+size)>>8;
buffer[2] = (3+size);
buffer[3] = ep_addr;
buffer[4] = SEPROXYHAL_TAG_USB_EP_PREPARE_DIR_IN;
buffer[5] = size;
io_seproxyhal_spi_send(buffer, 6);
io_seproxyhal_spi_send(pbuf, size);
return USBD_OK;
}
/**
* @brief Prepares an endpoint for reception.
* @param pdev: Device handle
* @param ep_addr: Endpoint Number
* @param pbuf: Pointer to data to be received
* @param size: Data size
* @retval USBD Status
*/
USBD_StatusTypeDef USBD_LL_PrepareReceive(USBD_HandleTypeDef *pdev,
uint8_t ep_addr,
uint16_t size)
{
uint8_t buffer[6];
buffer[0] = SEPROXYHAL_TAG_USB_EP_PREPARE;
buffer[1] = (3/*+size*/)>>8;
buffer[2] = (3/*+size*/);
buffer[3] = ep_addr;
buffer[4] = SEPROXYHAL_TAG_USB_EP_PREPARE_DIR_OUT;
buffer[5] = size;
io_seproxyhal_spi_send(buffer, 6);
return USBD_OK;
}
#if 0
/**
* @brief GPIO EXTI Callback function
* Handle USB VBUS detection upon External interrupt
* @param GPIO_Pin
* @retval None
*/
void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
if (GPIO_Pin == GPIO_PIN_9)
{
HAL_PCDEx_BCD_VBUSDetect (&hpcd_USB_OTG_FS);
}
}
/**
* @brief Returns the last transfered packet size.
* @param pdev: Device handle
* @param ep_addr: Endpoint Number
* @retval Recived Data Size
*/
uint32_t USBD_LL_GetRxDataSize (USBD_HandleTypeDef *pdev, uint8_t ep_addr)
{
// unused
return 0; //HAL_PCD_EP_GetRxCount(pdev->pData, ep_addr);
}
/**
* @brief Delays routine for the USB Device Library.
* @param Delay: Delay in ms
* @retval None
*/
void USBD_LL_Delay (uint32_t Delay)
{
// TODO
}
#endif //0
#if 0
/**
* @brief Software Device Connection
* @param hpcd: PCD handle
* @param state: connection state (0 : disconnected / 1: connected)
* @retval None
*/
void HAL_PCDEx_SetConnectionState(PCD_HandleTypeDef *hpcd, uint8_t state)
{
/* USER CODE BEGIN 6 */
if (state == 1)
{
/* Configure Low Connection State */
}
else
{
/* Configure High Connection State */
}
/* USER CODE END 6 */
}
/**
* @brief Verify if the Battery Charging Detection mode (BCD) is used :
* return USBD_OK if true
* else return USBD_FAIL if false
* @param pdev: Device handle
* @retval USBD Status
*/
USBD_StatusTypeDef USBD_LL_BatteryCharging(USBD_HandleTypeDef *pdev)
{
return USBD_FAIL;
}
#endif // 0
#include "usbd_def.h"
#include "usbd_core.h"
#include "os_io_seproxyhal.h"
#include "usbd_desc.h"
#include "usbd_customhid.h"
// the USB device
USBD_HandleTypeDef USBD_Device;
// endpoints transport length
volatile unsigned char G_io_usb_ep_xfer_len[IO_USB_MAX_ENDPOINTS];
// interaction variable with io seproxyhal to get the total length transferred when all RX packets have been processed.
extern volatile unsigned short G_io_apdu_length;
int8_t CUSTOM_HID_OutEvent (uint8_t* hid_report)
{
if (hid_report) {
// add to the hid transport
switch(io_usb_hid_receive(io_usb_send_apdu_data, hid_report, G_io_usb_ep_xfer_len[2])) {
default:
break;
case IO_USB_APDU_RECEIVED:
G_io_apdu_length = G_io_usb_hid_total_length;
break;
}
}
return (0);
}
void io_usb_enable(unsigned char enabled) {
if (enabled) {
os_memset(&USBD_Device, 0, sizeof(USBD_Device));
/* Init Device Library */
USBD_Init(&USBD_Device, &HID_Desc, 0);
/* Register the HID class */
USBD_RegisterClass(&USBD_Device, &USBD_CUSTOM_HID);
USBD_CUSTOM_HID_RegisterInterface(&USBD_Device, &USBD_CustomHID_template_fops);
/* Start Device Process */
USBD_Start(&USBD_Device);
}
else {
USBD_DeInit(&USBD_Device);
}
}
/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

177
src_usb/usbd_conf.h Normal file
View File

@ -0,0 +1,177 @@
/**
******************************************************************************
* @file : usbd_conf.h
* @brief : Header for usbd_conf file.
******************************************************************************
* COPYRIGHT(c) 2015 STMicroelectronics
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* 3. Neither the name of STMicroelectronics nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
******************************************************************************
*/
/* Define to prevent recursive inclusion -------------------------------------*/
#ifndef __USBD_CONF__H__
#define __USBD_CONF__H__
#ifdef __cplusplus
extern "C" {
#endif
/* Includes ------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
typedef signed char int8_t;
typedef unsigned char uint8_t;
typedef unsigned short uint16_t;
typedef signed short int16_t;
/** @addtogroup USBD_OTG_DRIVER
* @{
*/
/** @defgroup USBD_CONF
* @brief usb otg low level driver configuration file
* @{
*/
/** @defgroup USBD_CONF_Exported_Defines
* @{
*/
/*---------- -----------*/
#define USBD_MAX_NUM_INTERFACES 1
/*---------- -----------*/
#define USBD_MAX_NUM_CONFIGURATION 1
/*---------- -----------*/
#define USBD_MAX_STR_DESC_SIZ 512
/*---------- -----------*/
#define USBD_SUPPORT_USER_STRING 0
/*---------- -----------*/
#define USBD_DEBUG_LEVEL 0
/*---------- -----------*/
#define USBD_LPM_ENABLED 1
/*---------- -----------*/
#define USBD_SELF_POWERED 1
/****************************************/
/* #define for FS and HS identification */
#define DEVICE_FS 0
/** @defgroup USBD_Exported_Macros
* @{
*/
/* Memory management macros */
#define USBD_malloc (uint32_t *)USBD_static_malloc
#define USBD_free USBD_static_free
#define USBD_memset /* Not used */
#define USBD_memcpy /* Not used */
#define USBD_Delay HAL_Delay
/* DEBUG macros */
#if (USBD_DEBUG_LEVEL > 0)
#define USBD_UsrLog(...) printf(__VA_ARGS__);\
printf("\n");
#else
#define USBD_UsrLog(...)
#endif
#if (USBD_DEBUG_LEVEL > 1)
#define USBD_ErrLog(...) printf("ERROR: ") ;\
printf(__VA_ARGS__);\
printf("\n");
#else
#define USBD_ErrLog(...)
#endif
#if (USBD_DEBUG_LEVEL > 2)
#define USBD_DbgLog(...) printf("DEBUG : ") ;\
printf(__VA_ARGS__);\
printf("\n");
#else
#define USBD_DbgLog(...)
#endif
/**
* @}
*/
/**
* @}
*/
/** @defgroup USBD_CONF_Exported_Types
* @{
*/
/**
* @}
*/
/** @defgroup USBD_CONF_Exported_Macros
* @{
*/
/**
* @}
*/
/** @defgroup USBD_CONF_Exported_Variables
* @{
*/
/**
* @}
*/
/** @defgroup USBD_CONF_Exported_FunctionsPrototype
* @{
*/
/**
* @}
*/
/* Exported functions ------------------------------------------------------- */
void *USBD_static_malloc(uint32_t size);
void USBD_static_free(void *p);
#ifdef __cplusplus
}
#endif
#endif //__USBD_CONF__H__
/**
* @}
*/
/**
* @}
*/
/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

View File

@ -0,0 +1,78 @@
/**
******************************************************************************
* @file usbd_customhid_if_template.c
* @author MCD Application Team
* @version V2.2.0
* @date 13-June-2014
* @brief USB Device Custom HID interface file.
* This template should be copied to the user folder, renamed and customized
* following user needs.
******************************************************************************
* @attention
*
* <h2><center>&copy; COPYRIGHT(c) 2014 STMicroelectronics</center></h2>
*
* Licensed under MCD-ST Liberty SW License Agreement V2, (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.st.com/software_license_agreement_liberty_v2
*
* 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.
*
******************************************************************************
*/
/* Includes ------------------------------------------------------------------*/
#include "usbd_customhid_if_template.h"
/* Private typedef -----------------------------------------------------------*/
/* Private define ------------------------------------------------------------*/
/* Private macro -------------------------------------------------------------*/
/* Private function prototypes -----------------------------------------------*/
static int8_t CUSTOM_HID_Init (void);
static int8_t CUSTOM_HID_DeInit (void);
int8_t CUSTOM_HID_OutEvent (uint8_t* hid_report);
/* Private variables ---------------------------------------------------------*/
USBD_CUSTOM_HID_ItfTypeDef const USBD_CustomHID_template_fops =
{
CUSTOM_HID_Init,
CUSTOM_HID_DeInit,
CUSTOM_HID_OutEvent,
};
/* Private functions ---------------------------------------------------------*/
/**
* @brief TEMPLATE_CUSTOM_HID_Init
* Initializes the CUSTOM HID media low layer
* @param None
* @retval Result of the opeartion: USBD_OK if all operations are OK else USBD_FAIL
*/
static int8_t CUSTOM_HID_Init(void)
{
return (0);
}
/**
* @brief TEMPLATE_CUSTOM_HID_DeInit
* DeInitializes the CUSTOM HID media low layer
* @param None
* @retval Result of the opeartion: USBD_OK if all operations are OK else USBD_FAIL
*/
static int8_t CUSTOM_HID_DeInit(void)
{
/*
Add your deinitialization code here
*/
return (0);
}
/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

View File

@ -0,0 +1,49 @@
/**
******************************************************************************
* @file usbd_customhid_if_template.h
* @author MCD Application Team
* @version V2.2.0
* @date 13-June-2014
* @brief Header for usbd_customhid_if_template.c file.
******************************************************************************
* @attention
*
* <h2><center>&copy; COPYRIGHT(c) 2014 STMicroelectronics</center></h2>
*
* Licensed under MCD-ST Liberty SW License Agreement V2, (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.st.com/software_license_agreement_liberty_v2
*
* 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 th?
e specific language governing permissions and
* limitations under the License.
*
******************************************************************************
*/
/* Define to prevent recursive inclusion -------------------------------------*/
#ifndef __USBD_CUSTOM_HID_IF_TEMPLATE_H
#define __USBD_CUSTOM_HID_IF_TEMPLATE_H
#define USBD_CUSTOMHID_REPORT_DESC_SIZE 0x22
#define USBD_CUSTOMHID_OUTREPORT_BUF_SIZE 0x40
#define USBD_CUSTOM_HID_REPORT_DESC_SIZE 0x22
#define USBD_CUSTOM_HID_OUTREPORT_BUF_SIZE 0x40
/* Includes ------------------------------------------------------------------*/
#include "usbd_customhid.h"
/* Exported types ------------------------------------------------------------*/
/* Exported constants --------------------------------------------------------*/
/* Exported macro ------------------------------------------------------------*/
/* Exported functions ------------------------------------------------------- */
extern USBD_CUSTOM_HID_ItfTypeDef const USBD_CustomHID_template_fops;
#endif /* __USBD_CUSTOM_HID_IF_TEMPLATE_H */
/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

29
src_usb/usbd_desc.c Normal file
View File

@ -0,0 +1,29 @@
/**
******************************************************************************
* @file usbd_desc.c
* @author MCD Application Team
* @version V1.0.1
* @date 18-June-2014
* @brief This file provides the USBD descriptors and string formating method.
******************************************************************************
* @attention
*
* <h2><center>&copy; COPYRIGHT(c) 2014 STMicroelectronics</center></h2>
*
* Licensed under MCD-ST Liberty SW License Agreement V2, (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.st.com/software_license_agreement_liberty_v2
*
* 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.
*
******************************************************************************
*/
/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

48
src_usb/usbd_desc.h Normal file
View File

@ -0,0 +1,48 @@
/**
******************************************************************************
* @file usbd_desc.h
* @author MCD Application Team
* @version V1.0.1
* @date 18-June-2014
* @brief Header for usbd_desc.c module
******************************************************************************
* @attention
*
* <h2><center>&copy; COPYRIGHT(c) 2014 STMicroelectronics</center></h2>
*
* Licensed under MCD-ST Liberty SW License Agreement V2, (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.st.com/software_license_agreement_liberty_v2
*
* 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.
*
******************************************************************************
*/
/* Define to prevent recursive inclusion -------------------------------------*/
#ifndef __USBD_DESC_H
#define __USBD_DESC_H
/* Includes ------------------------------------------------------------------*/
#include "usbd_def.h"
/* Exported types ------------------------------------------------------------*/
/* Exported constants --------------------------------------------------------*/
#define DEVICE_ID1 (0x1FF80050)
#define DEVICE_ID2 (0x1FF80054)
#define DEVICE_ID3 (0x1FF80064)
#define USB_SIZ_STRING_SERIAL 0x1A
/* Exported macro ------------------------------------------------------------*/
/* Exported functions ------------------------------------------------------- */
extern const USBD_DescriptorsTypeDef HID_Desc;
#endif /* __USBD_DESC_H */
/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/