From: Jesse Hallio Date: Tue, 3 Feb 2015 21:22:39 +0000 (+0200) Subject: Add flasher from SVN r623 for HID bootprom and current Mac OS X kext X-Git-Tag: v2.0.0-rc1~29^2 X-Git-Url: https://git.zerfleddert.de/cgi-bin/gitweb.cgi/proxmark3-svn/commitdiff_plain/e9281ae812bd5b30394c78889034e653373f1397?ds=inline;hp=--cc Add flasher from SVN r623 for HID bootprom and current Mac OS X kext --- e9281ae812bd5b30394c78889034e653373f1397 diff --git a/client/Info.plist b/client/Info.plist deleted file mode 100644 index d1f87572..00000000 --- a/client/Info.plist +++ /dev/null @@ -1,30 +0,0 @@ - - - - - CFBundleDevelopmentRegion English - CFBundleIdentifier org.proxmark - CFBundleIconFile - CFBundleInfoDictionaryVersion 6.0 - CFBundlePackageType KEXT - CFBundleSignature ???? - CFBundleVersion 1.0.0 - IOKitPersonalities - - Proxmark3 - - CFBundleIdentifiercom.apple.kernel.iokit - IOClassIOService - IOProviderClassIOUSBInterface - bConfigurationValue 1 - bInterfaceNumber 0 - idProduct19343 - idVendor39620 - - - OSBundleLibraries - - com.apple.iokit.IOUSBFamily1.8 - - - diff --git a/client/Makefile b/client/Makefile index 823ee445..e63581ba 100644 --- a/client/Makefile +++ b/client/Makefile @@ -137,17 +137,6 @@ clean: tarbin: $(BINS) $(TAR) $(TARFLAGS) ../proxmark3-$(platform)-bin.tar $(BINS:%=client/%) -# must be run as root -install_kext: Info.plist - mkdir -p /System/Library/Extensions/Proxmark3.kext/Contents - cp Info.plist /System/Library/Extensions/Proxmark3.kext/Contents - chown -R root:wheel /System/Library/Extensions/Proxmark3.kext - chmod 755 /System/Library/Extensions/Proxmark3.kext /System/Library/Extensions/Proxmark3.kext/Contents - chmod 644 /System/Library/Extensions/Proxmark3.kext/Contents/Info.plist - rm -rf /System/Library/Caches/com.apple.kext.caches - touch /System/Library/Extensions - @echo "*** You may need to reboot for the kext to take effect." - lua_build: @echo Compiling liblua, using platform $(LUAPLATFORM) cd ../liblua && make $(LUAPLATFORM) diff --git a/client/hid-flasher/Info.plist b/client/hid-flasher/Info.plist new file mode 100644 index 00000000..c78a68ba --- /dev/null +++ b/client/hid-flasher/Info.plist @@ -0,0 +1,50 @@ + + + + + + + + + CFBundleDevelopmentRegion + English + CFBundleIconFile + + CFBundleIdentifier + com.proxmark.driver.dummy + CFBundleInfoDictionaryVersion + 6.0 + CFBundlePackageType + KEXT + CFBundleSignature + ???? + CFBundleVersion + 1.0.0d2 + IOKitPersonalities + + + Proxmark3 + + CFBundleIdentifier + com.apple.kpi.iokit + IOClass + IOService + IOProviderClass + IOUSBInterface + bConfigurationValue + 1 + bInterfaceNumber + 0 + idProduct + 19343 + idVendor + 39620 + + + OSBundleLibraries + + com.apple.iokit.IOUSBFamily + 1.8 + + + diff --git a/client/hid-flasher/Makefile b/client/hid-flasher/Makefile new file mode 100644 index 00000000..5e9b6fcd --- /dev/null +++ b/client/hid-flasher/Makefile @@ -0,0 +1,48 @@ +#----------------------------------------------------------------------------- +# This code is licensed to you under the terms of the GNU GPL, version 2 or, +# at your option, any later version. See the LICENSE.txt file for the text of +# the license. +#----------------------------------------------------------------------------- +include ../../common/Makefile.common + +CC=gcc +CXX=g++ +#COMMON_FLAGS = -m32 + +VPATH = ../../common +OBJDIR = obj + +LDLIBS = -L/opt/local/lib -L/usr/local/lib -lusb -lreadline -lpthread +LDFLAGS = $(COMMON_FLAGS) +CFLAGS = -std=gnu99 -I. -I../include -I../common -I/opt/local/include -Wall -Wno-unused-function $(COMMON_FLAGS) -g -O3 + +CXXFLAGS = +QTLDLIBS = + +RM = rm -f +BINS = flasher +CLEAN = flasher flasher.exe $(OBJDIR)/*.o *.o + +all: $(BINS) + +flasher: $(OBJDIR)/flash.o $(OBJDIR)/flasher.o $(OBJDIR)/proxusb.o + $(CXX) $(CXXFLAGS) $^ $(LDLIBS) -o $@ + +$(OBJDIR)/%.o: %.c + $(CC) $(CFLAGS) -c -o $@ $< + +clean: + $(RM) $(CLEAN) + +# must be run as root +install_kext: Info.plist + mkdir -p /System/Library/Extensions/Proxmark3.kext/Contents + cp Info.plist /System/Library/Extensions/Proxmark3.kext/Contents + chown -R root:wheel /System/Library/Extensions/Proxmark3.kext + chmod 755 /System/Library/Extensions/Proxmark3.kext /System/Library/Extensions/Proxmark3.kext/Contents + chmod 644 /System/Library/Extensions/Proxmark3.kext/Contents/Info.plist + rm -rf /System/Library/Caches/com.apple.kext.caches + touch /System/Library/Extensions + @echo "*** You may need to reboot for the kext to take effect." + +.PHONY: all clean diff --git a/client/hid-flasher/elf.h b/client/hid-flasher/elf.h new file mode 100644 index 00000000..90e20335 --- /dev/null +++ b/client/hid-flasher/elf.h @@ -0,0 +1,71 @@ +//----------------------------------------------------------------------------- +// This code is licensed to you under the terms of the GNU GPL, version 2 or, +// at your option, any later version. See the LICENSE.txt file for the text of +// the license. +//----------------------------------------------------------------------------- +// ELF header +//----------------------------------------------------------------------------- + +#ifndef __ELF_H__ +#define __ELF_H__ + +typedef struct { + uint32_t p_type; + uint32_t p_offset; + uint32_t p_vaddr; + uint32_t p_paddr; + uint32_t p_filesz; + uint32_t p_memsz; + uint32_t p_flags; + uint32_t p_align; +} __attribute__((__packed__)) Elf32_Phdr; + +#define EI_NIDENT 16 + +typedef struct { + unsigned char e_ident[EI_NIDENT]; + uint16_t e_type; + uint16_t e_machine; + uint32_t e_version; + uint32_t e_entry; + uint32_t e_phoff; + uint32_t e_shoff; + uint32_t e_flags; + uint16_t e_ehsize; + uint16_t e_phentsize; + uint16_t e_phnum; + uint16_t e_shentsize; + uint16_t e_shnum; + uint16_t e_shtrndx; +} __attribute__((__packed__)) Elf32_Ehdr; + +#define PT_NULL 0 +#define PT_LOAD 1 +#define PT_DYNAMIC 2 +#define PT_INTERP 3 +#define PT_NOTE 4 +#define PT_SHLIB 5 +#define PT_PHDR 6 + +#define ELFCLASS32 1 +#define ELFCLASS64 2 + +#define ELFDATA2LSB 1 +#define ELFDATA2MSB 2 + +#define EV_CURRENT 1 + +#define ET_NONE 0 +#define ET_REL 1 +#define ET_EXEC 2 +#define ET_DYN 3 +#define ET_CORE 4 + +#define EM_ARM 0x28 + +#define PF_R 4 +#define PF_W 2 +#define PF_X 1 + +#endif + diff --git a/client/hid-flasher/flash.c b/client/hid-flasher/flash.c new file mode 100644 index 00000000..6670d637 --- /dev/null +++ b/client/hid-flasher/flash.c @@ -0,0 +1,478 @@ +//----------------------------------------------------------------------------- +// Copyright (C) 2010 Hector Martin "marcan" +// +// This code is licensed to you under the terms of the GNU GPL, version 2 or, +// at your option, any later version. See the LICENSE.txt file for the text of +// the license. +//----------------------------------------------------------------------------- +// ELF file flasher +//----------------------------------------------------------------------------- + +#include +#include +#include +#include "sleep.h" +#include "proxusb.h" +#include "flash.h" +#include "elf.h" +#include "proxendian.h" + +// FIXME: what the fuckity fuck +unsigned int current_command = CMD_UNKNOWN; + +#define FLASH_START 0x100000 +#define FLASH_SIZE (256*1024) +#define FLASH_END (FLASH_START + FLASH_SIZE) +#define BOOTLOADER_SIZE 0x2000 +#define BOOTLOADER_END (FLASH_START + BOOTLOADER_SIZE) + +#define BLOCK_SIZE 0x100 + +static const uint8_t elf_ident[] = { + 0x7f, 'E', 'L', 'F', + ELFCLASS32, + ELFDATA2LSB, + EV_CURRENT +}; + +// Turn PHDRs into flasher segments, checking for PHDR sanity and merging adjacent +// unaligned segments if needed +static int build_segs_from_phdrs(flash_file_t *ctx, FILE *fd, Elf32_Phdr *phdrs, int num_phdrs) +{ + Elf32_Phdr *phdr = phdrs; + flash_seg_t *seg; + uint32_t last_end = 0; + + ctx->segments = malloc(sizeof(flash_seg_t) * num_phdrs); + if (!ctx->segments) { + fprintf(stderr, "Out of memory\n"); + return -1; + } + ctx->num_segs = 0; + seg = ctx->segments; + + fprintf(stderr, "Loading usable ELF segments:\n"); + for (int i = 0; i < num_phdrs; i++) { + if (le32(phdr->p_type) != PT_LOAD) { + phdr++; + continue; + } + uint32_t vaddr = le32(phdr->p_vaddr); + uint32_t paddr = le32(phdr->p_paddr); + uint32_t filesz = le32(phdr->p_filesz); + uint32_t memsz = le32(phdr->p_memsz); + uint32_t offset = le32(phdr->p_offset); + uint32_t flags = le32(phdr->p_flags); + if (!filesz) { + phdr++; + continue; + } + fprintf(stderr, "%d: V 0x%08x P 0x%08x (0x%08x->0x%08x) [%c%c%c] @0x%x\n", + i, vaddr, paddr, filesz, memsz, + flags & PF_R ? 'R' : ' ', + flags & PF_W ? 'W' : ' ', + flags & PF_X ? 'X' : ' ', + offset); + if (filesz != memsz) { + fprintf(stderr, "Error: PHDR file size does not equal memory size\n" + "(DATA+BSS PHDRs do not make sense on ROM platforms!)\n"); + return -1; + } + if (paddr < last_end) { + fprintf(stderr, "Error: PHDRs not sorted or overlap\n"); + return -1; + } + if (paddr < FLASH_START || (paddr+filesz) > FLASH_END) { + fprintf(stderr, "Error: PHDR is not contained in Flash\n"); + return -1; + } + if (vaddr >= FLASH_START && vaddr < FLASH_END && (flags & PF_W)) { + fprintf(stderr, "Error: Flash VMA segment is writable\n"); + return -1; + } + + uint8_t *data; + // make extra space if we need to move the data forward + data = malloc(filesz + BLOCK_SIZE); + if (!data) { + fprintf(stderr, "Out of memory\n"); + return -1; + } + if (fseek(fd, offset, SEEK_SET) < 0 || fread(data, 1, filesz, fd) != filesz) { + fprintf(stderr, "Error while reading PHDR payload\n"); + free(data); + return -1; + } + + uint32_t block_offset = paddr & (BLOCK_SIZE-1); + if (block_offset) { + if (ctx->num_segs) { + flash_seg_t *prev_seg = seg - 1; + uint32_t this_end = paddr + filesz; + uint32_t this_firstblock = paddr & ~(BLOCK_SIZE-1); + uint32_t prev_lastblock = (last_end - 1) & ~(BLOCK_SIZE-1); + + if (this_firstblock == prev_lastblock) { + uint32_t new_length = this_end - prev_seg->start; + uint32_t this_offset = paddr - prev_seg->start; + uint32_t hole = this_offset - prev_seg->length; + uint8_t *new_data = malloc(new_length); + if (!new_data) { + fprintf(stderr, "Out of memory\n"); + free(data); + return -1; + } + memset(new_data, 0xff, new_length); + memcpy(new_data, prev_seg->data, prev_seg->length); + memcpy(new_data + this_offset, data, filesz); + fprintf(stderr, "Note: Extending previous segment from 0x%x to 0x%x bytes\n", + prev_seg->length, new_length); + if (hole) + fprintf(stderr, "Note: 0x%x-byte hole created\n", hole); + free(data); + free(prev_seg->data); + prev_seg->data = new_data; + prev_seg->length = new_length; + last_end = this_end; + phdr++; + continue; + } + } + fprintf(stderr, "Warning: segment does not begin on a block boundary, will pad\n"); + memmove(data + block_offset, data, filesz); + memset(data, 0xFF, block_offset); + filesz += block_offset; + paddr -= block_offset; + } + + seg->data = data; + seg->start = paddr; + seg->length = filesz; + seg++; + ctx->num_segs++; + + last_end = paddr + filesz; + phdr++; + } + return 0; +} + +// Sanity check segments and check for bootloader writes +static int check_segs(flash_file_t *ctx, int can_write_bl) { + for (int i = 0; i < ctx->num_segs; i++) { + flash_seg_t *seg = &ctx->segments[i]; + + if (seg->start & (BLOCK_SIZE-1)) { + fprintf(stderr, "Error: Segment is not aligned\n"); + return -1; + } + if (seg->start < FLASH_START) { + fprintf(stderr, "Error: Segment is outside of flash bounds\n"); + return -1; + } + if (seg->start + seg->length > FLASH_END) { + fprintf(stderr, "Error: Segment is outside of flash bounds\n"); + return -1; + } + if (!can_write_bl && seg->start < BOOTLOADER_END) { + fprintf(stderr, "Attempted to write bootloader but bootloader writes are not enabled\n"); + return -1; + } + } + return 0; +} + +// Load an ELF file and prepare it for flashing +int flash_load(flash_file_t *ctx, const char *name, int can_write_bl) +{ + FILE *fd = NULL; + Elf32_Ehdr ehdr; + Elf32_Phdr *phdrs = NULL; + int num_phdrs; + int res; + + fd = fopen(name, "rb"); + if (!fd) { + fprintf(stderr, "Could not open file '%s': ", name); + perror(NULL); + goto fail; + } + + fprintf(stderr, "Loading ELF file '%s'...\n", name); + + if (fread(&ehdr, sizeof(ehdr), 1, fd) != 1) { + fprintf(stderr, "Error while reading ELF file header\n"); + goto fail; + } + if (memcmp(ehdr.e_ident, elf_ident, sizeof(elf_ident)) + || le32(ehdr.e_version) != 1) + { + fprintf(stderr, "Not an ELF file or wrong ELF type\n"); + goto fail; + } + if (le16(ehdr.e_type) != ET_EXEC) { + fprintf(stderr, "ELF is not executable\n"); + goto fail; + } + if (le16(ehdr.e_machine) != EM_ARM) { + fprintf(stderr, "Wrong ELF architecture\n"); + goto fail; + } + if (!ehdr.e_phnum || !ehdr.e_phoff) { + fprintf(stderr, "ELF has no PHDRs\n"); + goto fail; + } + if (le16(ehdr.e_phentsize) != sizeof(Elf32_Phdr)) { + // could be a structure padding issue... + fprintf(stderr, "Either the ELF file or this code is made of fail\n"); + goto fail; + } + num_phdrs = le16(ehdr.e_phnum); + + phdrs = malloc(le16(ehdr.e_phnum) * sizeof(Elf32_Phdr)); + if (!phdrs) { + fprintf(stderr, "Out of memory\n"); + goto fail; + } + if (fseek(fd, le32(ehdr.e_phoff), SEEK_SET) < 0) { + fprintf(stderr, "Error while reading ELF PHDRs\n"); + goto fail; + } + if (fread(phdrs, sizeof(Elf32_Phdr), num_phdrs, fd) != num_phdrs) { + fprintf(stderr, "Error while reading ELF PHDRs\n"); + goto fail; + } + + res = build_segs_from_phdrs(ctx, fd, phdrs, num_phdrs); + if (res < 0) + goto fail; + res = check_segs(ctx, can_write_bl); + if (res < 0) + goto fail; + + free(phdrs); + fclose(fd); + ctx->filename = name; + return 0; + +fail: + if (phdrs) + free(phdrs); + if (fd) + fclose(fd); + flash_free(ctx); + return -1; +} + +// Get the state of the proxmark, backwards compatible +static int get_proxmark_state(uint32_t *state) +{ + UsbCommand c; + c.cmd = CMD_DEVICE_INFO; + SendCommand(&c); + + UsbCommand resp; + ReceiveCommand(&resp); + + // Three outcomes: + // 1. The old bootrom code will ignore CMD_DEVICE_INFO, but respond with an ACK + // 2. The old os code will respond with CMD_DEBUG_PRINT_STRING and "unknown command" + // 3. The new bootrom and os codes will respond with CMD_DEVICE_INFO and flags + + switch (resp.cmd) { + case CMD_ACK: + *state = DEVICE_INFO_FLAG_CURRENT_MODE_BOOTROM; + break; + case CMD_DEBUG_PRINT_STRING: + *state = DEVICE_INFO_FLAG_CURRENT_MODE_OS; + break; + case CMD_DEVICE_INFO: + *state = resp.arg[0]; + break; + default: + fprintf(stderr, "Error: Couldn't get proxmark state, bad response type: 0x%04x\n", resp.cmd); + return -1; + break; + } + + return 0; +} + +// Enter the bootloader to be able to start flashing +static int enter_bootloader(void) +{ + uint32_t state; + + if (get_proxmark_state(&state) < 0) + return -1; + + if (state & DEVICE_INFO_FLAG_CURRENT_MODE_BOOTROM) { + /* Already in flash state, we're done. */ + return 0; + } + + if (state & DEVICE_INFO_FLAG_CURRENT_MODE_OS) { + fprintf(stderr,"Entering bootloader...\n"); + UsbCommand c; + memset(&c, 0, sizeof (c)); + + if ((state & DEVICE_INFO_FLAG_BOOTROM_PRESENT) + && (state & DEVICE_INFO_FLAG_OSIMAGE_PRESENT)) + { + // New style handover: Send CMD_START_FLASH, which will reset the board + // and enter the bootrom on the next boot. + c.cmd = CMD_START_FLASH; + SendCommand(&c); + fprintf(stderr,"(Press and release the button only to abort)\n"); + } else { + // Old style handover: Ask the user to press the button, then reset the board + c.cmd = CMD_HARDWARE_RESET; + SendCommand(&c); + fprintf(stderr,"Press and hold down button NOW if your bootloader requires it.\n"); + } + fprintf(stderr,"Waiting for Proxmark to reappear on USB..."); + + CloseProxmark(); + sleep(1); + while (!OpenProxmark(0)) { + sleep(1); + fprintf(stderr, "."); + } + fprintf(stderr," Found.\n"); + + return 0; + } + + fprintf(stderr, "Error: Unknown Proxmark mode\n"); + return -1; +} + +static int wait_for_ack(void) +{ + UsbCommand ack; + ReceiveCommand(&ack); + if (ack.cmd != CMD_ACK) { + printf("Error: Unexpected reply 0x%04x (expected ACK)\n", ack.cmd); + return -1; + } + return 0; +} + +// Go into flashing mode +int flash_start_flashing(int enable_bl_writes) +{ + uint32_t state; + + if (enter_bootloader() < 0) + return -1; + + if (get_proxmark_state(&state) < 0) + return -1; + + if (state & DEVICE_INFO_FLAG_UNDERSTANDS_START_FLASH) { + // This command is stupid. Why the heck does it care which area we're + // flashing, as long as it's not the bootloader area? The mind boggles. + UsbCommand c = {CMD_START_FLASH}; + + if (enable_bl_writes) { + c.arg[0] = FLASH_START; + c.arg[1] = FLASH_END; + c.arg[2] = START_FLASH_MAGIC; + } else { + c.arg[0] = BOOTLOADER_END; + c.arg[1] = FLASH_END; + c.arg[2] = 0; + } + SendCommand(&c); + return wait_for_ack(); + } else { + fprintf(stderr, "Note: Your bootloader does not understand the new START_FLASH command\n"); + fprintf(stderr, " It is recommended that you update your bootloader\n\n"); + } + + return 0; +} + +static int write_block(uint32_t address, uint8_t *data, uint32_t length) +{ + uint8_t block_buf[BLOCK_SIZE]; + + memset(block_buf, 0xFF, BLOCK_SIZE); + memcpy(block_buf, data, length); + + UsbCommand c = {CMD_SETUP_WRITE}; + for (int i = 0; i < 240; i += 48) { + memcpy(c.d.asBytes, block_buf + i, 48); + c.arg[0] = i / 4; + SendCommand(&c); + if (wait_for_ack() < 0) + return -1; + } + + c.cmd = CMD_FINISH_WRITE; + c.arg[0] = address; + memcpy(c.d.asBytes, block_buf+240, 16); + SendCommand(&c); + return wait_for_ack(); +} + +// Write a file's segments to Flash +int flash_write(flash_file_t *ctx) +{ + fprintf(stderr, "Writing segments for file: %s\n", ctx->filename); + for (int i = 0; i < ctx->num_segs; i++) { + flash_seg_t *seg = &ctx->segments[i]; + + uint32_t length = seg->length; + uint32_t blocks = (length + BLOCK_SIZE - 1) / BLOCK_SIZE; + uint32_t end = seg->start + length; + + fprintf(stderr, " 0x%08x..0x%08x [0x%x / %d blocks]", + seg->start, end - 1, length, blocks); + + int block = 0; + uint8_t *data = seg->data; + uint32_t baddr = seg->start; + + while (length) { + uint32_t block_size = length; + if (block_size > BLOCK_SIZE) + block_size = BLOCK_SIZE; + + if (write_block(baddr, data, block_size) < 0) { + fprintf(stderr, " ERROR\n"); + fprintf(stderr, "Error writing block %d of %d\n", block, blocks); + return -1; + } + + data += block_size; + baddr += block_size; + length -= block_size; + block++; + fprintf(stderr, "."); + } + fprintf(stderr, " OK\n"); + } + return 0; +} + +// free a file context +void flash_free(flash_file_t *ctx) +{ + if (!ctx) + return; + if (ctx->segments) { + for (int i = 0; i < ctx->num_segs; i++) + free(ctx->segments[i].data); + free(ctx->segments); + ctx->segments = NULL; + ctx->num_segs = 0; + } +} + +// just reset the unit +int flash_stop_flashing(void) { + UsbCommand c = {CMD_HARDWARE_RESET}; + SendCommand(&c); + return 0; +} diff --git a/client/hid-flasher/flash.h b/client/hid-flasher/flash.h new file mode 100644 index 00000000..d5f47b9d --- /dev/null +++ b/client/hid-flasher/flash.h @@ -0,0 +1,35 @@ +//----------------------------------------------------------------------------- +// This code is licensed to you under the terms of the GNU GPL, version 2 or, +// at your option, any later version. See the LICENSE.txt file for the text of +// the license. +//----------------------------------------------------------------------------- +// Flashing utility functions +//----------------------------------------------------------------------------- + +#ifndef __FLASH_H__ +#define __FLASH_H__ + +#include +#include "elf.h" + +typedef struct { + void *data; + uint32_t start; + uint32_t length; +} flash_seg_t; + +typedef struct { + const char *filename; + int can_write_bl; + int num_segs; + flash_seg_t *segments; +} flash_file_t; + +int flash_load(flash_file_t *ctx, const char *name, int can_write_bl); +int flash_start_flashing(int enable_bl_writes); +int flash_write(flash_file_t *ctx); +void flash_free(flash_file_t *ctx); +int flash_stop_flashing(void); + +#endif + diff --git a/client/hid-flasher/flasher.c b/client/hid-flasher/flasher.c new file mode 100644 index 00000000..a4a0e85e --- /dev/null +++ b/client/hid-flasher/flasher.c @@ -0,0 +1,93 @@ +//----------------------------------------------------------------------------- +// This code is licensed to you under the terms of the GNU GPL, version 2 or, +// at your option, any later version. See the LICENSE.txt file for the text of +// the license. +//----------------------------------------------------------------------------- +// Flasher frontend tool +//----------------------------------------------------------------------------- + +#include +#include +#include +#include "sleep.h" +#include "proxusb.h" +#include "flash.h" + +static void usage(char *argv0) +{ + fprintf(stderr, "Usage: %s [-b] image.elf [image.elf...]\n\n", argv0); + fprintf(stderr, "\t-b\tEnable flashing of bootloader area (DANGEROUS)\n\n"); + fprintf(stderr, "Example: %s path/to/osimage.elf path/to/fpgaimage.elf\n", argv0); +} + +#define MAX_FILES 4 + +int main(int argc, char **argv) +{ + int can_write_bl = 0; + int num_files = 0; + int res; + flash_file_t files[MAX_FILES]; + + memset(files, 0, sizeof(files)); + + if (argc < 2) { + usage(argv[0]); + return -1; + } + + for (int i = 1; i < argc; i++) { + if (argv[i][0] == '-') { + if (!strcmp(argv[i], "-b")) { + can_write_bl = 1; + } else { + usage(argv[0]); + return -1; + } + } else { + res = flash_load(&files[num_files], argv[i], can_write_bl); + if (res < 0) { + fprintf(stderr, "Error while loading %s\n", argv[i]); + return -1; + } + fprintf(stderr, "\n"); + num_files++; + } + } + + usb_init(); + + fprintf(stderr, "Waiting for Proxmark to appear on USB..."); + while (!OpenProxmark(1)) { + sleep(1); + fprintf(stderr, "."); + } + fprintf(stderr, " Found.\n"); + + res = flash_start_flashing(can_write_bl); + if (res < 0) + return -1; + + fprintf(stderr, "\nFlashing...\n"); + + for (int i = 0; i < num_files; i++) { + res = flash_write(&files[i]); + if (res < 0) + return -1; + flash_free(&files[i]); + fprintf(stderr, "\n"); + } + + fprintf(stderr, "Resetting hardware...\n"); + + res = flash_stop_flashing(); + if (res < 0) + return -1; + + CloseProxmark(); + + fprintf(stderr, "All done.\n\n"); + fprintf(stderr, "Have a nice day!\n"); + + return 0; +} diff --git a/client/hid-flasher/obj/.dummy b/client/hid-flasher/obj/.dummy new file mode 100644 index 00000000..e69de29b diff --git a/client/hid-flasher/proxendian.h b/client/hid-flasher/proxendian.h new file mode 100644 index 00000000..4a386a0d --- /dev/null +++ b/client/hid-flasher/proxendian.h @@ -0,0 +1,46 @@ +//----------------------------------------------------------------------------- +// Copyright (C) 2010 Hector Martin "marcan" +// +// This code is licensed to you under the terms of the GNU GPL, version 2 or, +// at your option, any later version. See the LICENSE.txt file for the text of +// the license. +//----------------------------------------------------------------------------- +// Endianness convenience functions +//----------------------------------------------------------------------------- + +#ifndef PROXENDIAN_H__ +#define PROXENDIAN_H__ + +#include + +#ifdef WIN32 +# define HOST_LITTLE_ENDIAN +#else +# include + +# if !defined(BYTE_ORDER) || (BYTE_ORDER != LITTLE_ENDIAN && BYTE_ORDER != BIG_ENDIAN) +# error Define BYTE_ORDER to be equal to either LITTLE_ENDIAN or BIG_ENDIAN +# endif + +# if BYTE_ORDER == LITTLE_ENDIAN +# define HOST_LITTLE_ENDIAN +# endif +#endif + +#ifdef HOST_LITTLE_ENDIAN +# define le16(x) (x) +# define le32(x) (x) +#else + +static inline uint16_t le16(uint16_t v) +{ + return (v>>8) | (v<<8); +} + +static inline uint32_t le32(uint32_t v) +{ + return (le16(v)<<16) | (le16(v>>16)); +} +#endif // HOST_LITTLE_ENDIAN + +#endif // PROXENDIAN_H__ diff --git a/client/hid-flasher/proxmark3.h b/client/hid-flasher/proxmark3.h new file mode 100644 index 00000000..f5dd2b7f --- /dev/null +++ b/client/hid-flasher/proxmark3.h @@ -0,0 +1,17 @@ +//----------------------------------------------------------------------------- +// Copyright (C) 2009 Michael Gernoth +// Copyright (C) 2010 iZsh +// +// This code is licensed to you under the terms of the GNU GPL, version 2 or, +// at your option, any later version. See the LICENSE.txt file for the text of +// the license. +//----------------------------------------------------------------------------- +// Main binary +//----------------------------------------------------------------------------- + +#ifndef PROXMARK3_H__ +#define PROXMARK3_H__ + +#define PROXPROMPT "proxmark3> " + +#endif diff --git a/client/hid-flasher/proxusb.c b/client/hid-flasher/proxusb.c new file mode 100644 index 00000000..3c2b20b4 --- /dev/null +++ b/client/hid-flasher/proxusb.c @@ -0,0 +1,222 @@ +//----------------------------------------------------------------------------- +// Copyright (C) 2009 Michael Gernoth +// Copyright (C) 2010 iZsh +// +// This code is licensed to you under the terms of the GNU GPL, version 2 or, +// at your option, any later version. See the LICENSE.txt file for the text of +// the license. +//----------------------------------------------------------------------------- +// USB utilities +//----------------------------------------------------------------------------- + +#include +#include +#include +#include +#include +#include +#include +#include + +#include "sleep.h" +#include "proxusb.h" +#include "proxmark3.h" +#include "usb_cmd.h" + +// It seems to be missing for mingw +#ifndef ETIMEDOUT +#define ETIMEDOUT 116 +#endif + +usb_dev_handle *devh = NULL; +static unsigned int claimed_iface = 0; +unsigned char return_on_error = 0; +unsigned char error_occured = 0; +extern unsigned int current_command; + +void SendCommand(UsbCommand *c) +{ + int ret; + +#if 0 + printf("Sending %d bytes\n", sizeof(UsbCommand)); +#endif + current_command = c->cmd; + ret = usb_bulk_write(devh, 0x01, (char*)c, sizeof(UsbCommand), 1000); + if (ret<0) { + error_occured = 1; + if (return_on_error) + return; + + fprintf(stderr, "write failed: %s!\nTrying to reopen device...\n", + usb_strerror()); + + if (devh) { + usb_close(devh); + devh = NULL; + } + while(!OpenProxmark(0)) { sleep(1); } + printf(PROXPROMPT); + fflush(NULL); + + return; + } +} + +bool ReceiveCommandPoll(UsbCommand *c) +{ + int ret; + + memset(c, 0, sizeof (UsbCommand)); + ret = usb_bulk_read(devh, 0x82, (char*)c, sizeof(UsbCommand), 500); + if (ret<0) { + if (ret != -ETIMEDOUT) { + error_occured = 1; + if (return_on_error) + return false; + + fprintf(stderr, "read failed: %s(%d)!\nTrying to reopen device...\n", + usb_strerror(), ret); + + if (devh) { + usb_close(devh); + devh = NULL; + } + while(!OpenProxmark(0)) { sleep(1); } + printf(PROXPROMPT); + fflush(NULL); + + return false; + } + } else { + if (ret && (ret < sizeof(UsbCommand))) { + fprintf(stderr, "Read only %d instead of requested %d bytes!\n", + ret, (int)sizeof(UsbCommand)); + } + } + + return ret > 0; +} + +void ReceiveCommand(UsbCommand *c) +{ +// printf("%s()\n", __FUNCTION__); + int retval = 0; + do { + retval = ReceiveCommandPoll(c); + if (retval != 1) printf("ReceiveCommandPoll returned %d\n", retval); + } while(retval<0); +// printf("recv %x\n", c->cmd); +} + +usb_dev_handle* findProxmark(int verbose, unsigned int *iface) +{ + struct usb_bus *busses, *bus; + usb_dev_handle *handle = NULL; + struct prox_unit units[50]; + int iUnit = 0; + + usb_find_busses(); + usb_find_devices(); + + busses = usb_get_busses(); + + for (bus = busses; bus; bus = bus->next) { + struct usb_device *dev; + + for (dev = bus->devices; dev; dev = dev->next) { + struct usb_device_descriptor *desc = &(dev->descriptor); + + if ((desc->idProduct == 0x4b8f) && (desc->idVendor == 0x9ac4)) { + handle = usb_open(dev); + if (!handle) { + if (verbose) + fprintf(stderr, "open fabiled: %s!\n", usb_strerror()); + //return NULL; + continue; + } + *iface = dev->config[0].interface[0].altsetting[0].bInterfaceNumber; + + struct prox_unit unit = {handle, {0}}; + usb_get_string_simple(handle, desc->iSerialNumber, unit.serial_number, sizeof(unit.serial_number)); + units[iUnit++] = unit; + + //return handle; + } + } + } + + if (iUnit > 0) { + int iSelection = 0; + + fprintf(stdout, "\nConnected units:\n"); + + for (int i = 0; i < iUnit; i++) { + struct usb_device * dev = usb_device(units[i].handle); + fprintf(stdout, "\t%d. SN: %s [%s/%s]\n", i+1, units[i].serial_number, dev->bus->dirname, dev->filename); + } + if (iUnit > 1) { + while (iSelection < 1 || iSelection > iUnit) { + fprintf(stdout, "Which unit do you want to connect to? "); + fscanf(stdin, "%d", &iSelection); + } + } + else + iSelection = 1; + iSelection --; + + for (int i = 0; i < iUnit; i++) { + if (iSelection == i) continue; + usb_close(units[i].handle); + units[i].handle = NULL; + } + + return units[iSelection].handle; + } + + return NULL; +} + +usb_dev_handle* OpenProxmark(int verbose) +{ + int ret; + usb_dev_handle *handle = NULL; + unsigned int iface; + + handle = findProxmark(verbose, &iface); + if (!handle) + return NULL; + +#ifdef __linux__ + /* detach kernel driver first */ + ret = usb_detach_kernel_driver_np(handle, iface); + /* don't complain if no driver attached */ + if (ret<0 && ret != -61 && verbose) + fprintf(stderr, "detach kernel driver failed: (%d) %s!\n", ret, usb_strerror()); +#endif + + // Needed for Windows. Optional for Mac OS and Linux + ret = usb_set_configuration(handle, 1); + if (ret < 0) { + if (verbose) + fprintf(stderr, "configuration set failed: %s!\n", usb_strerror()); + return NULL; + } + + ret = usb_claim_interface(handle, iface); + if (ret < 0) { + if (verbose) + fprintf(stderr, "claim failed: %s!\n", usb_strerror()); + return NULL; + } + claimed_iface = iface; + devh = handle; + return handle; +} + +void CloseProxmark(void) +{ + usb_release_interface(devh, claimed_iface); + usb_close(devh); + devh = NULL; +} diff --git a/client/hid-flasher/proxusb.h b/client/hid-flasher/proxusb.h new file mode 100644 index 00000000..5845888a --- /dev/null +++ b/client/hid-flasher/proxusb.h @@ -0,0 +1,34 @@ +//----------------------------------------------------------------------------- +// Copyright (C) 2010 iZsh +// +// This code is licensed to you under the terms of the GNU GPL, version 2 or, +// at your option, any later version. See the LICENSE.txt file for the text of +// the license. +//----------------------------------------------------------------------------- +// USB utilities +//----------------------------------------------------------------------------- + +#ifndef PROXUSB_H__ +#define PROXUSB_H__ + +#include +#include +#include +#include "usb_cmd.h" + +extern unsigned char return_on_error; +extern unsigned char error_occured; + +void SendCommand(UsbCommand *c); +bool ReceiveCommandPoll(UsbCommand *c); +void ReceiveCommand(UsbCommand *c); +struct usb_dev_handle* FindProxmark(int verbose, unsigned int *iface); +struct usb_dev_handle* OpenProxmark(int verbose); +void CloseProxmark(void); + +struct prox_unit { + usb_dev_handle *handle; + char serial_number[256]; +}; + +#endif diff --git a/client/hid-flasher/sleep.h b/client/hid-flasher/sleep.h new file mode 100644 index 00000000..81f4e060 --- /dev/null +++ b/client/hid-flasher/sleep.h @@ -0,0 +1,24 @@ +//----------------------------------------------------------------------------- +// Copyright (C) 2010 iZsh +// +// This code is licensed to you under the terms of the GNU GPL, version 2 or, +// at your option, any later version. See the LICENSE.txt file for the text of +// the license. +//----------------------------------------------------------------------------- +// platform-independant sleep macros +//----------------------------------------------------------------------------- + +#ifndef SLEEP_H__ +#define SLEEP_H__ + +#ifdef WIN32 +#include +#define sleep(n) Sleep(1000 * n) +#define msleep(n) Sleep(n) +#else +#include +#define msleep(n) usleep(1000 * n) +#endif + +#endif + diff --git a/client/hid-flasher/usb_cmd.h b/client/hid-flasher/usb_cmd.h new file mode 100644 index 00000000..a7552b3e --- /dev/null +++ b/client/hid-flasher/usb_cmd.h @@ -0,0 +1,165 @@ +//----------------------------------------------------------------------------- +// Jonathan Westhues, Mar 2006 +// Edits by Gerhard de Koning Gans, Sep 2007 +// +// This code is licensed to you under the terms of the GNU GPL, version 2 or, +// at your option, any later version. See the LICENSE.txt file for the text of +// the license. +//----------------------------------------------------------------------------- +// Definitions for all the types of commands that may be sent over USB; our +// own protocol. +//----------------------------------------------------------------------------- + +#ifndef __USB_CMD_H +#define __USB_CMD_H +#ifdef _MSC_VER +typedef DWORD uint32_t; +typedef BYTE uint8_t; +#define PACKED +// stuff +#else +#include +#include +#define PACKED __attribute__((packed)) +#endif + +typedef struct { + uint32_t cmd; + uint32_t arg[3]; + union { + uint8_t asBytes[48]; + uint32_t asDwords[12]; + } d; +} PACKED UsbCommand; + +// For the bootloader +#define CMD_DEVICE_INFO 0x0000 +#define CMD_SETUP_WRITE 0x0001 +#define CMD_FINISH_WRITE 0x0003 +#define CMD_HARDWARE_RESET 0x0004 +#define CMD_START_FLASH 0x0005 +#define CMD_NACK 0x00fe +#define CMD_ACK 0x00ff + +// For general mucking around +#define CMD_DEBUG_PRINT_STRING 0x0100 +#define CMD_DEBUG_PRINT_INTEGERS 0x0101 +#define CMD_DEBUG_PRINT_BYTES 0x0102 +#define CMD_LCD_RESET 0x0103 +#define CMD_LCD 0x0104 +#define CMD_BUFF_CLEAR 0x0105 +#define CMD_READ_MEM 0x0106 +#define CMD_VERSION 0x0107 + +// For low-frequency tags +#define CMD_READ_TI_TYPE 0x0202 +#define CMD_WRITE_TI_TYPE 0x0203 +#define CMD_DOWNLOADED_RAW_BITS_TI_TYPE 0x0204 +#define CMD_ACQUIRE_RAW_ADC_SAMPLES_125K 0x0205 +#define CMD_MOD_THEN_ACQUIRE_RAW_ADC_SAMPLES_125K 0x0206 +#define CMD_DOWNLOAD_RAW_ADC_SAMPLES_125K 0x0207 +#define CMD_DOWNLOADED_RAW_ADC_SAMPLES_125K 0x0208 +#define CMD_DOWNLOADED_SIM_SAMPLES_125K 0x0209 +#define CMD_SIMULATE_TAG_125K 0x020A +#define CMD_HID_DEMOD_FSK 0x020B +#define CMD_HID_SIM_TAG 0x020C +#define CMD_SET_LF_DIVISOR 0x020D +#define CMD_LF_SIMULATE_BIDIR 0x020E +#define CMD_SET_ADC_MUX 0x020F +#define CMD_HID_CLONE_TAG 0x0210 +#define CMD_EM410X_WRITE_TAG 0x0211 +#define CMD_INDALA_CLONE_TAG 0x0212 +// for 224 bits UID +#define CMD_INDALA_CLONE_TAG_L 0x0213 + +/* CMD_SET_ADC_MUX: ext1 is 0 for lopkd, 1 for loraw, 2 for hipkd, 3 for hiraw */ + +// For the 13.56 MHz tags +#define CMD_ACQUIRE_RAW_ADC_SAMPLES_ISO_15693 0x0300 +#define CMD_ACQUIRE_RAW_ADC_SAMPLES_ISO_14443 0x0301 +#define CMD_READ_SRI512_TAG 0x0303 +#define CMD_READ_SRIX4K_TAG 0x0304 +#define CMD_READER_ISO_15693 0x0310 +#define CMD_SIMTAG_ISO_15693 0x0311 +#define CMD_RECORD_RAW_ADC_SAMPLES_ISO_15693 0x0312 +#define CMD_ISO_15693_COMMAND 0x0313 +#define CMD_ISO_15693_COMMAND_DONE 0x0314 +#define CMD_ISO_15693_FIND_AFI 0x0315 +#define CMD_ISO_15693_DEBUG 0x0316 + +// For Hitag2 transponders +#define CMD_SNOOP_HITAG 0x0370 +#define CMD_SIMULATE_HITAG 0x0371 +#define CMD_READER_HITAG 0x0372 + +#define CMD_SIMULATE_TAG_HF_LISTEN 0x0380 +#define CMD_SIMULATE_TAG_ISO_14443 0x0381 +#define CMD_SNOOP_ISO_14443 0x0382 +#define CMD_SNOOP_ISO_14443a 0x0383 +#define CMD_SIMULATE_TAG_ISO_14443a 0x0384 +#define CMD_READER_ISO_14443a 0x0385 +#define CMD_SIMULATE_TAG_LEGIC_RF 0x0387 +#define CMD_READER_LEGIC_RF 0x0388 +#define CMD_WRITER_LEGIC_RF 0x0389 +#define CMD_EPA_PACE_COLLECT_NONCE 0x038A + +#define CMD_SNOOP_ICLASS 0x0392 +#define CMD_SIMULATE_TAG_ICLASS 0x0393 +#define CMD_READER_ICLASS 0x0394 + +// For measurements of the antenna tuning +#define CMD_MEASURE_ANTENNA_TUNING 0x0400 +#define CMD_MEASURE_ANTENNA_TUNING_HF 0x0401 +#define CMD_MEASURED_ANTENNA_TUNING 0x0410 +#define CMD_LISTEN_READER_FIELD 0x0420 + +// For direct FPGA control +#define CMD_FPGA_MAJOR_MODE_OFF 0x0500 + +// For mifare commands +#define CMD_MIFARE_SET_DBGMODE 0x0600 +#define CMD_MIFARE_EML_MEMCLR 0x0601 +#define CMD_MIFARE_EML_MEMSET 0x0602 +#define CMD_MIFARE_EML_MEMGET 0x0603 +#define CMD_MIFARE_EML_CARDLOAD 0x0604 +#define CMD_MIFARE_EML_CSETBLOCK 0x0605 +#define CMD_MIFARE_EML_CGETBLOCK 0x0606 + +#define CMD_SIMULATE_MIFARE_CARD 0x0610 + +#define CMD_READER_MIFARE 0x0611 +#define CMD_MIFARE_NESTED 0x0612 + +#define CMD_MIFARE_READBL 0x0620 +#define CMD_MIFARE_READSC 0x0621 +#define CMD_MIFARE_WRITEBL 0x0622 +#define CMD_MIFARE_CHKKEYS 0x0623 + +#define CMD_MIFARE_SNIFFER 0x0630 + +#define CMD_UNKNOWN 0xFFFF + +// CMD_DEVICE_INFO response packet has flags in arg[0], flag definitions: +/* Whether a bootloader that understands the common_area is present */ +#define DEVICE_INFO_FLAG_BOOTROM_PRESENT (1<<0) + +/* Whether a osimage that understands the common_area is present */ +#define DEVICE_INFO_FLAG_OSIMAGE_PRESENT (1<<1) + +/* Set if the bootloader is currently executing */ +#define DEVICE_INFO_FLAG_CURRENT_MODE_BOOTROM (1<<2) + +/* Set if the OS is currently executing */ +#define DEVICE_INFO_FLAG_CURRENT_MODE_OS (1<<3) + +/* Set if this device understands the extend start flash command */ +#define DEVICE_INFO_FLAG_UNDERSTANDS_START_FLASH (1<<4) + +/* CMD_START_FLASH may have three arguments: start of area to flash, + end of area to flash, optional magic. + The bootrom will not allow to overwrite itself unless this magic + is given as third parameter */ + +#define START_FLASH_MAGIC 0x54494f44 // 'DOIT' + +#endif