mirrors
/
rufus
mirror of https://github.com/pbatard/rufus.git
2
0
Fork 0
Code Issues Projects Releases Wiki Activity

[core] add SHA-256 validation DB for downloadable content 

* Downloadable content will now be indicating, in the log, whether it can be trusted with ✓ (validated) or ✗ (caution)
* Of course this validation only applies for files we know of, i.e. the downloadable content that existed at the time the DB was
  created. So, if Syslinux 8.x gets released tomorrow and we put it on our server, you'll get an ✗ regardless of its integrity.
* Closes #758
This commit is contained in:
Pete Batard 2016-05-25 12:20:20 +01:00
parent 04d6ac0cdd
commit 790aacd49a
10 changed files with 201 additions and 43 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
src/.msvc/rufus.vcxproj
View File

@ -222,6 +222,7 @@
<ClInclude Include="..\resource.h" /> <ClInclude Include="..\resource.h" />
<ClInclude Include="..\rufus.h" /> <ClInclude Include="..\rufus.h" />
<ClInclude Include="..\license.h" /> <ClInclude Include="..\license.h" />
<ClInclude Include="..\db.h" />
<ClInclude Include="..\smart.h" /> <ClInclude Include="..\smart.h" />
<ClInclude Include="..\sys_types.h" /> <ClInclude Include="..\sys_types.h" />
<ClInclude Include="..\dev.h" /> <ClInclude Include="..\dev.h" />

3
src/.msvc/rufus.vcxproj.filters
View File

@ -140,6 +140,9 @@
<ClInclude Include="..\dev.h"> <ClInclude Include="..\dev.h">
<Filter>Header Files</Filter> <Filter>Header Files</Filter>
</ClInclude> </ClInclude>
<ClInclude Include="..\db.h">
<Filter>Header Files</Filter>
</ClInclude>
</ItemGroup> </ItemGroup>
<ItemGroup> <ItemGroup>
<None Include="..\..\res\rufus.ico"> <None Include="..\..\res\rufus.ico">

62
src/checksum.c
View File

@ -51,6 +51,7 @@
#include <errno.h> #include <errno.h>
#include <windowsx.h> #include <windowsx.h>
#include "db.h"
#include "rufus.h" #include "rufus.h"
#include "missing.h" #include "missing.h"
#include "resource.h" #include "resource.h"
@ -714,19 +715,18 @@ sum_write_t *sum_write[CHECKSUM_MAX] = { md5_write, sha1_write , sha256_write };
sum_final_t *sum_final[CHECKSUM_MAX] = { md5_final, sha1_final , sha256_final }; sum_final_t *sum_final[CHECKSUM_MAX] = { md5_final, sha1_final , sha256_final };
// Compute an individual checksum without threading or buffering, for a single file // Compute an individual checksum without threading or buffering, for a single file
BOOL Checksum(const unsigned type, const char* path, uint8_t* sum) BOOL HashFile(const unsigned type, const char* path, uint8_t* sum)
{ {
BOOL r = FALSE; BOOL r = FALSE;
SUM_CONTEXT sum_ctx = { 0 }; SUM_CONTEXT sum_ctx = { 0 };
HANDLE h = INVALID_HANDLE_VALUE; HANDLE h = INVALID_HANDLE_VALUE;
DWORD read_size = 0; DWORD rs = 0;
uint64_t rb; uint64_t rb;
char buffer[4096]; unsigned char buf[4096];
if ((type >= CHECKSUM_MAX) || (path == NULL) || (sum == NULL)) if ((type >= CHECKSUM_MAX) || (path == NULL) || (sum == NULL))
goto out; goto out;
uprintf("\r\nComputing checksum for '%s'...", path);
h = CreateFileU(path, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_FLAG_SEQUENTIAL_SCAN, NULL); h = CreateFileU(path, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_FLAG_SEQUENTIAL_SCAN, NULL);
if (h == INVALID_HANDLE_VALUE) { if (h == INVALID_HANDLE_VALUE) {
uprintf("Could not open file: %s", WindowsErrorString()); uprintf("Could not open file: %s", WindowsErrorString());
@ -735,16 +735,16 @@ BOOL Checksum(const unsigned type, const char* path, uint8_t* sum)
} }
sum_init[type](&sum_ctx); sum_init[type](&sum_ctx);
for (rb = 0; ; rb += read_size) { for (rb = 0; ; rb += rs) {
CHECK_FOR_USER_CANCEL; CHECK_FOR_USER_CANCEL;
if (!ReadFile(h, buffer, sizeof(buffer), &read_size, NULL)) { if (!ReadFile(h, buf, sizeof(buf), &rs, NULL)) {
FormatStatus = ERROR_SEVERITY_ERROR | FAC(FACILITY_STORAGE) | ERROR_READ_FAULT; FormatStatus = ERROR_SEVERITY_ERROR | FAC(FACILITY_STORAGE) | ERROR_READ_FAULT;
uprintf(" Read error: %s", WindowsErrorString()); uprintf(" Read error: %s", WindowsErrorString());
goto out; goto out;
} }
if (read_size == 0) if (rs == 0)
break; break;
sum_write[type](&sum_ctx, buffer, (size_t)read_size); sum_write[type](&sum_ctx, buf, (size_t)rs);
} }
sum_final[type](&sum_ctx); sum_final[type](&sum_ctx);
@ -756,6 +756,25 @@ out:
return r; return r;
} }
BOOL HashBuffer(const unsigned type, const unsigned char* buf, const size_t len, uint8_t* sum)
{
BOOL r = FALSE;
SUM_CONTEXT sum_ctx = { 0 };
if ((type >= CHECKSUM_MAX) || (sum == NULL))
goto out;
sum_init[type](&sum_ctx);
sum_write[type](&sum_ctx, buf, len);
sum_final[type](&sum_ctx);
memcpy(sum, sum_ctx.buf, sum_count[type]);
r = TRUE;
out:
return r;
}
/* /*
* Checksum dialog callback * Checksum dialog callback
*/ */
@ -975,3 +994,30 @@ out:
MyDialogBox(hMainInstance, IDD_CHECKSUM, hMainDialog, ChecksumCallback); MyDialogBox(hMainInstance, IDD_CHECKSUM, hMainDialog, ChecksumCallback);
ExitThread(r); ExitThread(r);
} }
/*
* The following 2 calls are used to check whether a buffer/file is in our hash DB
*/
BOOL IsBufferInDB(const unsigned char* buf, const size_t len)
{
int i;
uint8_t sum[32];
if (!HashBuffer(CHECKSUM_SHA256, buf, len, sum))
return FALSE;
for (i = 0; i < ARRAYSIZE(sha256db); i += 32)
if (memcmp(sum, &sha256db[i], 32) == 0)
return TRUE;
return FALSE;
}
BOOL IsFileInDB(const char* path)
{
int i;
uint8_t sum[32];
if (!HashFile(CHECKSUM_SHA256, path, sum))
return FALSE;
for (i = 0; i < ARRAYSIZE(sha256db); i += 32)
if (memcmp(sum, &sha256db[i], 32) == 0)
return TRUE;
return FALSE;
}

108
src/db.h Normal file
View File

@ -0,0 +1,108 @@
/*
* Rufus: The Reliable USB Formatting Utility
* DB of the hash values we know for downloadable content (GRUB, Syslinux, etc.)
* Copyright © 2016 Pete Batard <pete@akeo.ie>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <stdint.h>
#pragma once
/*
* NB: Table data was generated from the files/ directory the server with:
* find . -not -name "*.txt" -not -name "*.sh" -not -name "*pre*" -type f -print0 | xargs -0 sha256sum | awk '{print $1}' | sort | uniq | xxd -r -p | hexdump -v -e '31/1 "0x%02x, " 1/1 " 0x%02x,\n"'
*/
static uint8_t sha256db[] = {
0x12, 0xbd, 0x22, 0xd2, 0xb3, 0x69, 0x56, 0x0f, 0x89, 0xb8, 0x50, 0x7e, 0x7e, 0x74, 0xeb, 0xc5, 0xea, 0x44, 0x91, 0x48, 0x75, 0xf0, 0xa4, 0xcb, 0x1e, 0xa6, 0xfb, 0x4e, 0xc9, 0x89, 0x58, 0x17,
0x15, 0x5f, 0x36, 0x7b, 0xb1, 0x30, 0xfe, 0x05, 0x5c, 0x79, 0x9f, 0x88, 0xb3, 0xc0, 0xc1, 0xa0, 0x0a, 0x18, 0x05, 0x78, 0x22, 0x69, 0xcf, 0x7e, 0x54, 0xaa, 0x61, 0xbd, 0xe3, 0x8e, 0x05, 0x92,
0x1c, 0xb7, 0x8b, 0x98, 0xbc, 0xd6, 0x76, 0x7b, 0x01, 0x44, 0xf5, 0x00, 0xaf, 0x81, 0xef, 0x4f, 0x3c, 0x54, 0xea, 0xaf, 0xe3, 0xc9, 0x4e, 0x1f, 0xd6, 0x24, 0x68, 0x41, 0x4e, 0x98, 0x92, 0x25,
0x1c, 0xc6, 0x32, 0x21, 0xfd, 0xf4, 0x46, 0xfc, 0xda, 0xc6, 0xc0, 0x56, 0x35, 0x79, 0x54, 0xc1, 0x5b, 0x61, 0x75, 0xca, 0x1b, 0xc2, 0xa4, 0x9f, 0x85, 0x52, 0xec, 0xca, 0x28, 0xac, 0x3e, 0x51,
0x22, 0x96, 0x82, 0xac, 0x61, 0xb8, 0x8b, 0x11, 0x25, 0xfc, 0xd7, 0xe6, 0x9f, 0x4e, 0x7f, 0x46, 0x7f, 0x68, 0xc5, 0x14, 0x9e, 0xb9, 0x37, 0x1a, 0x98, 0xd8, 0xf2, 0x78, 0x41, 0x40, 0xad, 0x88,
0x25, 0xd1, 0x38, 0xf3, 0x8b, 0x17, 0x35, 0x79, 0x3e, 0xee, 0x89, 0x19, 0xa3, 0xa0, 0xe5, 0xc9, 0x97, 0x9d, 0x2f, 0xac, 0xc0, 0xb5, 0x70, 0x74, 0x24, 0xe8, 0x04, 0x98, 0x1d, 0x25, 0xf9, 0xc9,
0x2b, 0x31, 0x7b, 0x12, 0xab, 0xff, 0x49, 0x66, 0x48, 0x78, 0xdf, 0xe0, 0xb5, 0x00, 0xb8, 0x50, 0x0f, 0x93, 0xf1, 0xd5, 0xe4, 0xd5, 0x28, 0x45, 0x95, 0xcc, 0x2c, 0x15, 0x6c, 0x74, 0x4f, 0x79,
0x2d, 0x99, 0x55, 0x09, 0xd0, 0xd6, 0xcd, 0xf7, 0x6e, 0xd5, 0x9f, 0x46, 0x53, 0xf1, 0xcb, 0xe1, 0xc9, 0xe6, 0x24, 0xe1, 0xaf, 0xa8, 0xf7, 0x8e, 0xc2, 0x45, 0x5b, 0x24, 0x53, 0x4b, 0x87, 0x76,
0x2e, 0x3e, 0xf6, 0x65, 0x1e, 0x59, 0x85, 0x20, 0x26, 0xc5, 0x74, 0xde, 0x52, 0x65, 0xf6, 0x8e, 0x24, 0xf8, 0xe6, 0x27, 0xc5, 0x53, 0xce, 0x8d, 0x32, 0x7c, 0xa7, 0xe0, 0xb4, 0x96, 0x70, 0xa1,
0x31, 0x17, 0x97, 0x0e, 0x89, 0xe2, 0xab, 0xd6, 0x7e, 0x29, 0x26, 0x63, 0xf3, 0xe2, 0xcf, 0xa7, 0xc3, 0xfe, 0xe8, 0x7a, 0x87, 0x0a, 0xb9, 0x20, 0xc8, 0xa1, 0x74, 0xff, 0x5d, 0xfb, 0xfe, 0x8e,
0x33, 0x02, 0x03, 0xb6, 0x29, 0x5e, 0x7c, 0x60, 0x72, 0x5f, 0x07, 0xc0, 0x92, 0x15, 0xd1, 0x75, 0xaa, 0x09, 0x23, 0xee, 0xd5, 0x5a, 0xec, 0xb5, 0x72, 0x77, 0x76, 0x4d, 0x6b, 0xdc, 0xf1, 0x31,
0x34, 0x08, 0x54, 0xee, 0x4f, 0x7f, 0x10, 0xaa, 0x63, 0x38, 0xba, 0xeb, 0xa4, 0xdd, 0xd1, 0xca, 0x9c, 0xbd, 0x15, 0x6f, 0x04, 0x86, 0x69, 0x66, 0x6c, 0x92, 0xe4, 0x85, 0x47, 0x6e, 0xe9, 0x41,
0x34, 0x1b, 0x76, 0x83, 0x3c, 0xc6, 0x1c, 0x1c, 0xd0, 0xde, 0x84, 0x2c, 0xcb, 0xfe, 0x38, 0x4f, 0x0b, 0x21, 0xb1, 0x10, 0x0e, 0xaa, 0x74, 0xf9, 0x5f, 0x07, 0x21, 0x72, 0x4f, 0x00, 0x6f, 0x74,
0x37, 0x9f, 0x06, 0xfe, 0xee, 0x22, 0xf0, 0xd5, 0x8f, 0xf9, 0x9b, 0xb3, 0x47, 0xf9, 0x9e, 0x0a, 0x1a, 0x23, 0xaf, 0x03, 0x1e, 0x35, 0x13, 0x02, 0xd2, 0xf7, 0x63, 0x55, 0xc9, 0xc7, 0x90, 0xb2,
0x38, 0x48, 0x38, 0xcf, 0x85, 0x08, 0x18, 0x04, 0x0a, 0xf2, 0xb3, 0xd8, 0x71, 0x38, 0xb4, 0x49, 0x12, 0xb0, 0x0d, 0x4f, 0x17, 0xb1, 0xba, 0x41, 0xbd, 0x06, 0x1a, 0xf4, 0x6d, 0x56, 0x61, 0x62,
0x39, 0xde, 0x1f, 0x87, 0x08, 0xef, 0xd8, 0x88, 0x56, 0x91, 0x68, 0x5e, 0xfc, 0x59, 0x45, 0x48, 0xdf, 0x29, 0xfb, 0x20, 0x0b, 0xc1, 0x56, 0x7f, 0x1b, 0xd7, 0xcf, 0xce, 0x6f, 0x95, 0x55, 0xe0,
0x3c, 0x39, 0x1b, 0x51, 0x04, 0xec, 0xdb, 0x65, 0x33, 0x01, 0xd2, 0xe2, 0x20, 0x0a, 0x6d, 0xab, 0xc0, 0xdb, 0x59, 0xd8, 0x80, 0x7b, 0xe9, 0x47, 0x99, 0x51, 0xbe, 0x18, 0x61, 0x53, 0x20, 0xad,
0x3d, 0x3c, 0xba, 0x34, 0x12, 0xe1, 0xba, 0xf6, 0x01, 0xaf, 0xbb, 0x6d, 0xf0, 0x09, 0x75, 0xa0, 0x8c, 0xc0, 0xad, 0x7c, 0x62, 0xfd, 0x50, 0x15, 0x87, 0x08, 0xeb, 0x4c, 0x8c, 0x3d, 0x95, 0x55,
0x3f, 0x12, 0x06, 0xe0, 0xcc, 0x45, 0xdb, 0xe1, 0x80, 0xe7, 0x3a, 0xda, 0xeb, 0x22, 0x1b, 0xfc, 0x7d, 0x5a, 0x80, 0x00, 0x95, 0x73, 0x85, 0x49, 0x39, 0x03, 0x79, 0xd7, 0xd0, 0x28, 0x2a, 0xc3,
0x40, 0xe7, 0x8e, 0x0b, 0x92, 0xb9, 0x80, 0x60, 0xbf, 0x28, 0x9b, 0xa6, 0xab, 0x68, 0x22, 0x5b, 0x61, 0xe2, 0x5e, 0x08, 0x9e, 0xd5, 0xa6, 0x16, 0x94, 0xc5, 0x19, 0x17, 0x92, 0x5f, 0x3e, 0x8d,
0x40, 0xe7, 0x99, 0x43, 0xac, 0x71, 0xde, 0xf1, 0xc0, 0x35, 0x5a, 0xec, 0x71, 0xb4, 0xf7, 0x8d, 0xcf, 0x19, 0x20, 0x4a, 0x97, 0xe9, 0x7e, 0x0f, 0x34, 0x17, 0x50, 0x65, 0x32, 0xc9, 0x02, 0x76,
0x42, 0x23, 0x03, 0x86, 0x6d, 0xa1, 0xf2, 0xaf, 0x28, 0x25, 0x92, 0x29, 0x17, 0x21, 0xc7, 0x61, 0x23, 0xcf, 0xe9, 0x84, 0x05, 0xb7, 0x60, 0x2a, 0xc7, 0xe3, 0xe9, 0x5b, 0xf3, 0xcb, 0xd4, 0xba,
0x44, 0xb2, 0xed, 0x6b, 0x5a, 0xc4, 0x92, 0x4b, 0xde, 0x88, 0x92, 0x89, 0x58, 0x18, 0xe0, 0x5c, 0x15, 0x26, 0x2c, 0xe5, 0x7e, 0x52, 0xca, 0x59, 0x52, 0x5a, 0x92, 0xda, 0xb4, 0xe3, 0xf6, 0x22,
0x46, 0x48, 0xe8, 0x13, 0xd7, 0x54, 0x20, 0x39, 0x4e, 0xe6, 0x35, 0xd2, 0xa4, 0x78, 0x44, 0xeb, 0xdc, 0xc9, 0x98, 0xd3, 0x45, 0x8f, 0x95, 0xf9, 0x50, 0x80, 0x50, 0x9b, 0x88, 0x80, 0x44, 0x4a,
0x47, 0x0c, 0x04, 0x6d, 0xe8, 0x53, 0x5d, 0x46, 0x0e, 0x05, 0x63, 0x99, 0xa8, 0x89, 0x28, 0x0b, 0x25, 0x55, 0xf2, 0xb7, 0xbf, 0x89, 0x84, 0x9a, 0x7f, 0x27, 0xa4, 0x32, 0x72, 0xb5, 0x3f, 0x12,
0x4d, 0xee, 0xc3, 0x47, 0xb0, 0xa3, 0x18, 0x46, 0x09, 0x42, 0xb2, 0xeb, 0x3e, 0xd1, 0x75, 0xcf, 0x3f, 0x8c, 0x3e, 0x8c, 0xe4, 0x3b, 0x14, 0xfc, 0x8e, 0x8f, 0x8c, 0x51, 0xcb, 0xa5, 0x5a, 0xdb,
0x4e, 0xfb, 0x8f, 0xde, 0xb9, 0xe1, 0xe2, 0xa2, 0xc3, 0xf0, 0x11, 0xca, 0x77, 0x3b, 0x95, 0xf4, 0xb9, 0x7f, 0xbc, 0x7f, 0x3d, 0x40, 0x4d, 0x7c, 0x60, 0xf3, 0x4a, 0x61, 0x43, 0x44, 0x7e, 0x7f,
0x50, 0xca, 0xe9, 0x94, 0x79, 0x68, 0xdf, 0xa6, 0xd7, 0x11, 0xcd, 0xb0, 0x7d, 0x84, 0xf2, 0x56, 0x78, 0xd6, 0x69, 0xbf, 0xb0, 0x29, 0xaa, 0x56, 0xa1, 0x04, 0x55, 0xb0, 0xcd, 0x06, 0xca, 0xd2,
0x52, 0x0b, 0x46, 0x87, 0x46, 0x22, 0xb5, 0xa6, 0x57, 0x83, 0xdb, 0x7c, 0x12, 0x42, 0x53, 0x2d, 0x13, 0x7f, 0x95, 0xfe, 0xbf, 0x4d, 0xf9, 0xc2, 0x7e, 0x67, 0x94, 0x3a, 0x21, 0x27, 0xf6, 0x08,
0x54, 0x4b, 0x3e, 0x86, 0xfc, 0xa2, 0x7a, 0x12, 0xf4, 0x81, 0xfd, 0x32, 0x53, 0x57, 0x1c, 0xc5, 0xe6, 0x1a, 0x19, 0xed, 0x9a, 0x43, 0xbc, 0x12, 0xa8, 0x07, 0x6d, 0x90, 0x8f, 0x98, 0x39, 0x6f,
0x55, 0xb9, 0x27, 0xd2, 0x17, 0xe8, 0x83, 0xd9, 0xe1, 0x58, 0xc9, 0x51, 0x80, 0xb1, 0xba, 0x79, 0x97, 0x3a, 0xd3, 0xd9, 0x44, 0xc2, 0xc6, 0xa1, 0xed, 0x49, 0x5c, 0xd3, 0xef, 0xc3, 0x54, 0x1c,
0x56, 0x7a, 0x32, 0x6a, 0x20, 0x9a, 0xe8, 0x69, 0x9a, 0x7d, 0xb5, 0xc0, 0xa4, 0x34, 0x52, 0x71, 0x05, 0x1e, 0x0a, 0x84, 0x03, 0xae, 0x21, 0x13, 0xd9, 0xd0, 0x12, 0xc4, 0x8d, 0x99, 0xa4, 0x13,
0x57, 0x45, 0x0a, 0xf8, 0xa4, 0xe0, 0x06, 0x71, 0x11, 0x46, 0xaa, 0x53, 0x1f, 0xe5, 0x59, 0x8f, 0x9e, 0x92, 0xe7, 0x3d, 0x6c, 0xea, 0x93, 0x06, 0x02, 0x13, 0xa3, 0x08, 0xce, 0x76, 0x11, 0x29,
0x5b, 0xf5, 0xb8, 0x10, 0xa4, 0x4a, 0x27, 0xd8, 0x72, 0xae, 0x50, 0x68, 0xa4, 0xc0, 0x06, 0x93, 0xcb, 0xa2, 0x41, 0xd7, 0x96, 0x51, 0x07, 0xfb, 0x20, 0xd0, 0x18, 0x17, 0x92, 0x36, 0x16, 0x81,
0x5c, 0xef, 0x9a, 0xd0, 0xd0, 0xca, 0x04, 0x09, 0x72, 0x62, 0x24, 0x16, 0x86, 0xc6, 0xc3, 0xa7, 0x30, 0x6a, 0xb9, 0xb9, 0xcd, 0xf2, 0x4b, 0x9d, 0x4e, 0xe3, 0xb1, 0x6a, 0xf0, 0x1a, 0x5a, 0xf2,
0x5e, 0xd2, 0x81, 0xa6, 0x95, 0xbe, 0x85, 0x95, 0x64, 0x02, 0xb2, 0x30, 0x51, 0x2c, 0x49, 0x96, 0x4a, 0x46, 0x24, 0xc9, 0xd7, 0x55, 0xcd, 0x1c, 0xda, 0xa7, 0x37, 0x6c, 0x2f, 0x7f, 0x41, 0xb9,
0x67, 0x64, 0x0d, 0x11, 0xfe, 0x80, 0x78, 0x17, 0x57, 0x0e, 0xf1, 0x6d, 0xeb, 0xe8, 0x21, 0xb5, 0xd3, 0x93, 0x51, 0x78, 0x3a, 0x5f, 0xa7, 0x61, 0x7b, 0xa2, 0x55, 0x30, 0xec, 0x4d, 0xd8, 0x77,
0x68, 0x40, 0xb3, 0xda, 0xf8, 0x6d, 0xba, 0x9f, 0x8e, 0x64, 0x22, 0xdb, 0x59, 0x54, 0x67, 0x64, 0xe3, 0xb1, 0x44, 0x61, 0x9a, 0x70, 0xb5, 0xac, 0x27, 0x88, 0x50, 0x5e, 0xdb, 0xc6, 0x17, 0x6c,
0x6a, 0x8e, 0xf8, 0x3a, 0xd5, 0x52, 0xfe, 0x72, 0x37, 0xdf, 0xea, 0x8a, 0x13, 0x4e, 0x14, 0xa4, 0x03, 0x6a, 0x78, 0x74, 0x97, 0x63, 0x03, 0x92, 0x5e, 0xd3, 0x84, 0xf7, 0xc6, 0x92, 0xa6, 0x0d,
0x6a, 0xbc, 0xdc, 0x80, 0x3a, 0x30, 0x85, 0xea, 0x5f, 0x9d, 0xa1, 0xb4, 0x3e, 0xdb, 0x2e, 0xad, 0xa2, 0x75, 0x36, 0x0d, 0xb8, 0x11, 0xc9, 0xac, 0xf5, 0x9a, 0x55, 0x5f, 0x67, 0x7b, 0x2d, 0x8b,
0x75, 0x6f, 0x89, 0x25, 0x23, 0xc6, 0x8d, 0x27, 0x32, 0x28, 0x8b, 0x5a, 0xd4, 0x2d, 0x7d, 0xc7, 0x4e, 0xa7, 0xa7, 0x08, 0x9b, 0x04, 0x2b, 0x12, 0x5f, 0x5d, 0x74, 0x7f, 0xf3, 0x20, 0xa0, 0x77,
0x77, 0x9a, 0x5e, 0xbd, 0x69, 0xd3, 0x28, 0x5e, 0xb9, 0xed, 0x4a, 0xc7, 0xc0, 0x4d, 0x2d, 0x15, 0xcb, 0xa1, 0x8a, 0x1f, 0x97, 0xc7, 0xc4, 0xbe, 0x62, 0x48, 0x93, 0xa9, 0xe1, 0xb0, 0x89, 0x2e,
0x78, 0x64, 0x8e, 0xf0, 0xc5, 0x00, 0x41, 0x75, 0xb9, 0xa8, 0xea, 0x33, 0x30, 0x14, 0xea, 0x02, 0xc9, 0x17, 0xf8, 0x23, 0xe7, 0x7a, 0x3e, 0xc9, 0xac, 0xd9, 0xd2, 0x2b, 0x46, 0x02, 0xf3, 0x6d,
0x7d, 0xa9, 0xc5, 0x21, 0x76, 0xb8, 0xaf, 0x01, 0x64, 0xea, 0x39, 0x21, 0x22, 0x44, 0xb1, 0x0a, 0xa0, 0xc7, 0x97, 0xe7, 0x65, 0xbb, 0x6b, 0x92, 0x69, 0xb5, 0x8b, 0xc9, 0xe5, 0x0a, 0x9f, 0x18,
0x82, 0x11, 0xfa, 0xe8, 0xaf, 0xf0, 0x23, 0x3f, 0x05, 0xa8, 0xb7, 0x8c, 0x58, 0x15, 0x25, 0xe2, 0x81, 0xac, 0x98, 0x23, 0x54, 0xa8, 0xc4, 0x3b, 0xb4, 0x96, 0x5e, 0x61, 0xdc, 0x98, 0xb4, 0x62,
0x83, 0x9b, 0xd0, 0x8a, 0xcb, 0x68, 0x47, 0xd6, 0x55, 0x07, 0xf1, 0x4e, 0x7a, 0x55, 0x6e, 0x91, 0xe6, 0x12, 0x9c, 0x47, 0x86, 0x3f, 0x7d, 0x61, 0xe2, 0xce, 0x6d, 0xb7, 0x8d, 0xf3, 0xd2, 0x3f,
0x83, 0xb9, 0xb1, 0x58, 0xcc, 0xc5, 0x73, 0xc2, 0x17, 0xff, 0x46, 0x0b, 0x9d, 0xfb, 0x18, 0x67, 0xf4, 0xe7, 0x50, 0xf2, 0x61, 0xa9, 0x6e, 0x46, 0x05, 0x6e, 0xc1, 0x1f, 0x47, 0xb1, 0x23, 0x82,
0x87, 0xaa, 0x91, 0xf8, 0x7f, 0xba, 0x5f, 0x31, 0x79, 0x43, 0x08, 0xda, 0xa4, 0xa4, 0x8d, 0xad, 0x6c, 0xf6, 0xfa, 0x34, 0x26, 0x4d, 0x66, 0xb8, 0x84, 0xb8, 0xb9, 0xdc, 0x96, 0x42, 0xed, 0x86,
0x88, 0x14, 0xe5, 0x76, 0xab, 0xc1, 0xaa, 0x44, 0xdd, 0xe9, 0x43, 0xb0, 0xca, 0xae, 0xe8, 0x33, 0xa5, 0x81, 0x01, 0x42, 0x61, 0x4a, 0xde, 0xeb, 0x4c, 0xc7, 0x25, 0xe7, 0x8a, 0x50, 0x45, 0xb7,
0x8b, 0x93, 0x7e, 0x5e, 0x8b, 0xae, 0x5a, 0xf8, 0xc8, 0x95, 0x63, 0xc0, 0x0e, 0x9c, 0xaf, 0xc6, 0xcd, 0x7c, 0x2c, 0x80, 0x8a, 0xda, 0x7b, 0xf4, 0xad, 0x51, 0x08, 0xda, 0x3e, 0x51, 0xcd, 0x70,
0x8e, 0xc8, 0x42, 0x06, 0x94, 0x4c, 0xd4, 0x3d, 0xf6, 0xba, 0x83, 0x63, 0xc0, 0x81, 0xe4, 0xa0, 0x82, 0x9e, 0x71, 0x9a, 0xbf, 0x5a, 0x46, 0x6d, 0x7c, 0x81, 0x0c, 0x2f, 0x5b, 0x6d, 0x13, 0x75,
0x95, 0x8d, 0x10, 0xbb, 0x87, 0x28, 0xcc, 0x1f, 0xf1, 0x6a, 0x12, 0xee, 0x6a, 0x60, 0x62, 0x40, 0xa6, 0xb7, 0x4d, 0xab, 0xa0, 0x2b, 0x8c, 0xb8, 0xed, 0x2a, 0xe8, 0x1c, 0x2f, 0xb2, 0x5b, 0x97,
0x9a, 0x0b, 0xc4, 0x1b, 0xd7, 0x95, 0xed, 0xb0, 0x83, 0x0f, 0x1c, 0xc4, 0x82, 0x4b, 0xfa, 0x9d, 0xe0, 0x9d, 0x68, 0x63, 0x92, 0x09, 0x4f, 0x5a, 0xe7, 0xfb, 0xac, 0xfb, 0xb0, 0x17, 0x9d, 0xa6,
0x9b, 0xcc, 0x65, 0x92, 0xa7, 0xba, 0x7e, 0x73, 0x38, 0xf4, 0xbb, 0xba, 0x27, 0xc6, 0x30, 0x16, 0xb9, 0x5e, 0xcb, 0x1e, 0xc6, 0x8c, 0x0b, 0xe9, 0xb6, 0x99, 0xb2, 0xea, 0x69, 0xcb, 0xab, 0xb2,
0x9c, 0x63, 0xbe, 0xef, 0xc7, 0x59, 0x86, 0xe5, 0x79, 0x5d, 0x02, 0x8a, 0xe4, 0x48, 0xc1, 0x09, 0x38, 0x62, 0x1d, 0xd7, 0x6a, 0x89, 0x7e, 0x4f, 0x08, 0x2a, 0x42, 0x12, 0x93, 0x0b, 0x1c, 0x2e,
0xa6, 0x82, 0x43, 0xa0, 0xf2, 0xe5, 0x90, 0xb8, 0x14, 0x02, 0xd6, 0xfa, 0x62, 0xd4, 0xfd, 0x30, 0x94, 0x8c, 0x00, 0x3d, 0xa1, 0x2b, 0xfe, 0xeb, 0x69, 0xba, 0x20, 0x34, 0x17, 0x27, 0x09, 0x4c,
0xa9, 0x4a, 0x99, 0xe6, 0xde, 0x68, 0x81, 0x44, 0x49, 0x2b, 0x38, 0xdb, 0xee, 0x09, 0xde, 0x07, 0x30, 0xe3, 0x2e, 0x1c, 0xfd, 0x0a, 0xb2, 0x54, 0x99, 0x22, 0xff, 0xa8, 0x04, 0x01, 0xad, 0x49,
0xa9, 0x95, 0x68, 0x57, 0x9c, 0xd2, 0x51, 0xaf, 0xf1, 0x34, 0xfc, 0xaa, 0xa8, 0x09, 0x91, 0x60, 0x5e, 0x8f, 0xb1, 0x19, 0x74, 0x51, 0xf7, 0x51, 0xaa, 0x4d, 0x6c, 0x84, 0xbf, 0x65, 0xf4, 0xe3,
0xb2, 0xf0, 0xde, 0x2e, 0x01, 0xa7, 0xe3, 0x4d, 0x96, 0xa9, 0x76, 0x36, 0x43, 0x05, 0xd3, 0x9f, 0xf8, 0x49, 0xd5, 0x0a, 0xd1, 0x3a, 0xd1, 0xf8, 0xa8, 0xb4, 0x41, 0x1d, 0x1d, 0x53, 0x4e, 0x88,
0xb3, 0xa8, 0xf2, 0x12, 0x89, 0x1c, 0xd2, 0x6e, 0x1a, 0xb4, 0x4a, 0xa8, 0x59, 0x8f, 0x6e, 0x64, 0xc6, 0x83, 0x19, 0x8d, 0x43, 0x00, 0x27, 0x54, 0xec, 0xbd, 0x8a, 0x78, 0xf2, 0xd0, 0xc0, 0x0b,
0xb3, 0xdc, 0x31, 0x79, 0xf6, 0x2b, 0x20, 0x51, 0xc9, 0x43, 0xe5, 0x2e, 0xeb, 0xf2, 0x29, 0x8a, 0xa4, 0x7e, 0x7c, 0x0a, 0x97, 0x78, 0xe8, 0x62, 0x77, 0xa7, 0x48, 0x2a, 0x27, 0x0a, 0x7a, 0x8e,
0xb4, 0x6a, 0xf2, 0x09, 0x19, 0xe9, 0xf2, 0x1f, 0xa1, 0x52, 0x37, 0x5d, 0xda, 0xc4, 0x58, 0x87, 0x08, 0xc1, 0x22, 0xb3, 0x65, 0x7f, 0x09, 0x01, 0x31, 0x4e, 0x83, 0x45, 0x49, 0xa9, 0x6c, 0xe7,
0xbf, 0xf9, 0xc5, 0x89, 0x59, 0x70, 0x4d, 0x1e, 0xbe, 0x25, 0xb4, 0x43, 0xc8, 0x92, 0x3a, 0x42, 0xed, 0x89, 0xaf, 0x8b, 0xd2, 0x92, 0xe7, 0xd7, 0xcb, 0xeb, 0xca, 0xcc, 0xc0, 0x7c, 0xc7, 0x19,
0xc3, 0x3b, 0x31, 0x5f, 0xec, 0xe4, 0xad, 0xc4, 0xc3, 0xb2, 0x75, 0x13, 0x22, 0x84, 0x66, 0xe4, 0x44, 0x99, 0xcd, 0xa7, 0xfd, 0x63, 0x97, 0xc5, 0xab, 0xe0, 0xf8, 0xce, 0x4f, 0xe3, 0x45, 0x39,
0xcd, 0x08, 0xf4, 0x81, 0xfb, 0x0c, 0xda, 0x19, 0xe1, 0x78, 0x6d, 0x43, 0x8d, 0x5c, 0x13, 0x93, 0xf7, 0xbf, 0xf3, 0x81, 0x31, 0x44, 0x4a, 0x0a, 0x5e, 0x54, 0xc1, 0x04, 0xed, 0x1d, 0x4d, 0xad,
0xd0, 0x15, 0x48, 0xaf, 0x46, 0xf6, 0x4f, 0xed, 0x16, 0x69, 0xa5, 0x6e, 0x69, 0x31, 0x56, 0xb5, 0xde, 0x39, 0xd6, 0xbf, 0xa8, 0x6e, 0x9e, 0x07, 0x13, 0x1d, 0x70, 0x06, 0x3c, 0x56, 0x3d, 0xd0,
0xd1, 0x19, 0x76, 0xaf, 0xd6, 0x28, 0x03, 0xff, 0xa7, 0x60, 0x9a, 0x59, 0x18, 0xa8, 0x7a, 0xf2, 0xd1, 0x7b, 0x5d, 0x15, 0x8f, 0x14, 0x0d, 0x11, 0xdf, 0x5c, 0x17, 0x44, 0x9e, 0xb4, 0xe4, 0xaf,
0xd2, 0xc6, 0x93, 0x8d, 0xae, 0x5a, 0xd7, 0x16, 0x0e, 0x9e, 0x6c, 0x61, 0xef, 0x46, 0xb7, 0xfd, 0x14, 0x6e, 0x30, 0xc0, 0x3f, 0xdc, 0x8f, 0x5c, 0x6d, 0xbd, 0xeb, 0x86, 0x22, 0xc8, 0xa7, 0xbd,
0xd5, 0x50, 0x39, 0xef, 0xb6, 0x8d, 0x6e, 0xec, 0xde, 0x68, 0x61, 0xc9, 0x0b, 0xa9, 0xb7, 0x99, 0x44, 0xd1, 0xaa, 0x8b, 0xc3, 0xd6, 0x01, 0xfb, 0x80, 0xfd, 0x08, 0x7b, 0xc6, 0x13, 0x63, 0xf8,
0xd9, 0x1c, 0xbd, 0xf9, 0x01, 0x79, 0x5e, 0x98, 0x19, 0x84, 0x9c, 0x75, 0x3e, 0xa5, 0x3a, 0xd8, 0x59, 0xc6, 0xf2, 0x5d, 0x59, 0x17, 0xa6, 0x75, 0x92, 0x58, 0x3f, 0xd6, 0x5e, 0x6d, 0x00, 0xf0,
0xe7, 0x87, 0x08, 0xc7, 0x2c, 0x49, 0x8e, 0xcc, 0x14, 0x9e, 0x30, 0xf0, 0xa9, 0x85, 0xd3, 0x73, 0xa3, 0x00, 0xad, 0x5c, 0xf7, 0xd2, 0x88, 0xc7, 0x7d, 0xe8, 0x05, 0x5e, 0x25, 0x66, 0x28, 0x1f,
0xe9, 0x00, 0x3a, 0x56, 0x28, 0x43, 0xa3, 0x7b, 0xec, 0x4b, 0xef, 0xd4, 0xbb, 0x71, 0xfe, 0x3c, 0x5e, 0x6a, 0x50, 0x4d, 0x0b, 0x99, 0x36, 0xaf, 0xb6, 0x9e, 0xdc, 0x37, 0x2f, 0x7c, 0x41, 0xef,
0xec, 0x31, 0xc2, 0xb7, 0xba, 0x09, 0xee, 0x69, 0xee, 0xf8, 0x55, 0x31, 0xe2, 0xc2, 0x4f, 0x22, 0x4a, 0xf7, 0xd9, 0x4a, 0x72, 0x25, 0xb2, 0x6f, 0x4f, 0x57, 0xf7, 0x70, 0x5e, 0x7d, 0xda, 0x1a,
0xec, 0x94, 0x7e, 0x1c, 0x1e, 0x3f, 0xbe, 0xca, 0x4f, 0x55, 0x6d, 0x7a, 0x1a, 0x41, 0x15, 0x60, 0x89, 0x41, 0xf5, 0x48, 0x35, 0xe0, 0x7e, 0x8e, 0x89, 0xf7, 0x02, 0x85, 0x3d, 0xb7, 0xae, 0x2a,
0xec, 0xfd, 0xbc, 0x3f, 0x4f, 0x2e, 0x4d, 0x99, 0x16, 0x9c, 0xdd, 0xfb, 0x15, 0x2d, 0x92, 0x4d, 0x7d, 0xe6, 0x8a, 0xb6, 0x7f, 0x4d, 0x12, 0x54, 0x40, 0xfa, 0xbc, 0x9f, 0x00, 0x46, 0xd5, 0xbc,
0xee, 0xed, 0xc0, 0x4c, 0x13, 0x73, 0xb5, 0xc4, 0x04, 0x4d, 0x1f, 0xde, 0x0d, 0x2f, 0xb8, 0xe2, 0x8c, 0x74, 0xb1, 0x02, 0x9c, 0x99, 0xed, 0x67, 0x0a, 0x15, 0x98, 0x3f, 0x18, 0xa0, 0x4d, 0x36,
0xf5, 0x40, 0x26, 0x1c, 0x09, 0x7d, 0xbd, 0x8a, 0x8a, 0x12, 0x9b, 0x68, 0x99, 0x5f, 0x33, 0xab, 0xe7, 0x1c, 0x29, 0x40, 0xf8, 0x87, 0xc6, 0x68, 0x9b, 0xf8, 0xdc, 0x3f, 0x1a, 0xcf, 0x0b, 0x44,
0xfb, 0x0a, 0x23, 0xca, 0x4d, 0x22, 0xfd, 0xd2, 0xad, 0x4e, 0xfa, 0x1b, 0x21, 0x08, 0xb6, 0x60, 0xd2, 0xff, 0xa3, 0xf2, 0xfb, 0xdd, 0x25, 0x32, 0xdc, 0xf1, 0x3f, 0x49, 0x33, 0x28, 0x46, 0x7b,
0xfb, 0x49, 0xfd, 0x45, 0x8c, 0xaf, 0x47, 0x5a, 0x16, 0x05, 0x5e, 0x4a, 0x75, 0x5a, 0xc3, 0xe3, 0x95, 0x52, 0xf4, 0xe9, 0x6c, 0xa2, 0x0d, 0xea, 0x53, 0xf5, 0xc4, 0x09, 0x2b, 0x68, 0xfd, 0x4f,
};

10
src/format.c
View File

@ -1002,7 +1002,7 @@ static BOOL WriteSBR(HANDLE hPhysicalDrive)
switch (bt) { switch (bt) {
case BT_GRUB4DOS: case BT_GRUB4DOS:
uprintf("Writing Grub4Dos SBR..."); uprintf("Writing Grub4Dos SBR");
buf = GetResource(hMainInstance, MAKEINTRESOURCEA(IDR_GR_GRUB_GRLDR_MBR), _RT_RCDATA, "grldr.mbr", &size, FALSE); buf = GetResource(hMainInstance, MAKEINTRESOURCEA(IDR_GR_GRUB_GRLDR_MBR), _RT_RCDATA, "grldr.mbr", &size, FALSE);
if ((buf == NULL) || (size <= mbr_size)) { if ((buf == NULL) || (size <= mbr_size)) {
uprintf("grldr.mbr is either not present or too small"); uprintf("grldr.mbr is either not present or too small");
@ -1013,11 +1013,12 @@ static BOOL WriteSBR(HANDLE hPhysicalDrive)
break; break;
case BT_GRUB2: case BT_GRUB2:
if (grub2_buf != NULL) { if (grub2_buf != NULL) {
uprintf("Writing Grub 2.0 SBR (from download)..."); uprintf("Writing Grub 2.0 SBR (from download) %s",
IsBufferInDB(grub2_buf, grub2_len)?"✓":"✗");
buf = grub2_buf; buf = grub2_buf;
size = (DWORD)grub2_len; size = (DWORD)grub2_len;
} else { } else {
uprintf("Writing Grub 2.0 SBR (from embedded)..."); uprintf("Writing Grub 2.0 SBR (from embedded)");
buf = GetResource(hMainInstance, MAKEINTRESOURCEA(IDR_GR_GRUB2_CORE_IMG), _RT_RCDATA, "core.img", &size, FALSE); buf = GetResource(hMainInstance, MAKEINTRESOURCEA(IDR_GR_GRUB2_CORE_IMG), _RT_RCDATA, "core.img", &size, FALSE);
if (buf == NULL) { if (buf == NULL) {
uprintf("Could not access core.img"); uprintf("Could not access core.img");
@ -1898,8 +1899,9 @@ DWORD WINAPI FormatThread(void* param)
} }
} else if (bt == BT_GRUB4DOS) { } else if (bt == BT_GRUB4DOS) {
grub4dos_dst[0] = drive_name[0]; grub4dos_dst[0] = drive_name[0];
uprintf("Installing: %s (Grub4DOS loader)\n", grub4dos_dst);
IGNORE_RETVAL(_chdirU(app_dir)); IGNORE_RETVAL(_chdirU(app_dir));
uprintf("Installing: %s (Grub4DOS loader) %s\n", grub4dos_dst,
IsFileInDB(FILES_DIR "\\grub4dos-" GRUB4DOS_VERSION "\\grldr")?"✓":"✗");
if (!CopyFileU(FILES_DIR "\\grub4dos-" GRUB4DOS_VERSION "\\grldr", grub4dos_dst, FALSE)) if (!CopyFileU(FILES_DIR "\\grub4dos-" GRUB4DOS_VERSION "\\grldr", grub4dos_dst, FALSE))
uprintf("Failed to copy file: %s", WindowsErrorString()); uprintf("Failed to copy file: %s", WindowsErrorString());
} else if ((bt == BT_ISO) && (image_path != NULL)) { } else if ((bt == BT_ISO) && (image_path != NULL)) {

30
src/iso.c
View File

@ -366,7 +366,7 @@ static int udf_extract_files(udf_t *p_udf, udf_dirent_t *p_udf_dirent, const cha
i_length = (int)(3 + strlen(psz_path) + strlen(psz_basename) + strlen(psz_extract_dir) + 24); i_length = (int)(3 + strlen(psz_path) + strlen(psz_basename) + strlen(psz_extract_dir) + 24);
psz_fullpath = (char*)calloc(sizeof(char), i_length); psz_fullpath = (char*)calloc(sizeof(char), i_length);
if (psz_fullpath == NULL) { if (psz_fullpath == NULL) {
uprintf("Error allocating file name\n"); uprintf("Error allocating file name");
goto out; goto out;
} }
i_length = _snprintf(psz_fullpath, i_length, "%s%s/%s", psz_extract_dir, psz_path, psz_basename); i_length = _snprintf(psz_fullpath, i_length, "%s%s/%s", psz_extract_dir, psz_path, psz_basename);
@ -398,23 +398,23 @@ static int udf_extract_files(udf_t *p_udf, udf_dirent_t *p_udf_dirent, const cha
for (i=0; i<NB_OLD_C32; i++) { for (i=0; i<NB_OLD_C32; i++) {
if (props.is_old_c32[i] && use_own_c32[i]) { if (props.is_old_c32[i] && use_own_c32[i]) {
static_sprintf(tmp, "%s/syslinux-%s/%s", FILES_DIR, embedded_sl_version_str[0], old_c32_name[i]); static_sprintf(tmp, "%s/syslinux-%s/%s", FILES_DIR, embedded_sl_version_str[0], old_c32_name[i]);
if (CopyFileA(tmp, psz_fullpath, FALSE)) { if (CopyFileU(tmp, psz_fullpath, FALSE)) {
uprintf(" Replaced with local version\n"); uprintf(" Replaced with local version %s", IsFileInDB(tmp)?"✓":"✗");
break; break;
} }
uprintf(" Could not replace file: %s\n", WindowsErrorString()); uprintf(" Could not replace file: %s", WindowsErrorString());
} }
} }
if (i < NB_OLD_C32) if (i < NB_OLD_C32)
continue; continue;
psz_sanpath = sanitize_filename(psz_fullpath, &is_identical); psz_sanpath = sanitize_filename(psz_fullpath, &is_identical);
if (!is_identical) if (!is_identical)
uprintf(" File name sanitized to '%s'\n", psz_sanpath); uprintf(" File name sanitized to '%s'", psz_sanpath);
file_handle = CreateFileU(psz_sanpath, GENERIC_READ | GENERIC_WRITE, file_handle = CreateFileU(psz_sanpath, GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL); FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
if (file_handle == INVALID_HANDLE_VALUE) { if (file_handle == INVALID_HANDLE_VALUE) {
err = GetLastError(); err = GetLastError();
uprintf(" Unable to create file: %s\n", WindowsErrorString()); uprintf(" Unable to create file: %s", WindowsErrorString());
if ((err == ERROR_ACCESS_DENIED) && (safe_strcmp(&psz_sanpath[3], autorun_name) == 0)) if ((err == ERROR_ACCESS_DENIED) && (safe_strcmp(&psz_sanpath[3], autorun_name) == 0))
uprintf(stupid_antivirus); uprintf(stupid_antivirus);
else else
@ -424,7 +424,7 @@ static int udf_extract_files(udf_t *p_udf, udf_dirent_t *p_udf_dirent, const cha
memset(buf, 0, UDF_BLOCKSIZE); memset(buf, 0, UDF_BLOCKSIZE);
i_read = udf_read_block(p_udf_dirent, buf, 1); i_read = udf_read_block(p_udf_dirent, buf, 1);
if (i_read < 0) { if (i_read < 0) {
uprintf(" Error reading UDF file %s\n", &psz_fullpath[strlen(psz_extract_dir)]); uprintf(" Error reading UDF file %s", &psz_fullpath[strlen(psz_extract_dir)]);
goto out; goto out;
} }
buf_size = (DWORD)MIN(i_file_length, i_read); buf_size = (DWORD)MIN(i_file_length, i_read);
@ -491,7 +491,7 @@ static int iso_extract_files(iso9660_t* p_iso, const char *psz_path)
p_entlist = iso9660_ifs_readdir(p_iso, psz_path); p_entlist = iso9660_ifs_readdir(p_iso, psz_path);
if (!p_entlist) { if (!p_entlist) {
uprintf("Could not access directory %s\n", psz_path); uprintf("Could not access directory %s", psz_path);
return 1; return 1;
} }
@ -539,28 +539,28 @@ static int iso_extract_files(iso9660_t* p_iso, const char *psz_path)
for (i=0; i<NB_OLD_C32; i++) { for (i=0; i<NB_OLD_C32; i++) {
if (props.is_old_c32[i] && use_own_c32[i]) { if (props.is_old_c32[i] && use_own_c32[i]) {
static_sprintf(tmp, "%s/syslinux-%s/%s", FILES_DIR, embedded_sl_version_str[0], old_c32_name[i]); static_sprintf(tmp, "%s/syslinux-%s/%s", FILES_DIR, embedded_sl_version_str[0], old_c32_name[i]);
if (CopyFileA(tmp, psz_fullpath, FALSE)) { if (CopyFileU(tmp, psz_fullpath, FALSE)) {
uprintf(" Replaced with local version\n"); uprintf(" Replaced with local version %s", IsFileInDB(tmp)?"✓":"✗");
break; break;
} }
uprintf(" Could not replace file: %s\n", WindowsErrorString()); uprintf(" Could not replace file: %s", WindowsErrorString());
} }
} }
if (i < NB_OLD_C32) if (i < NB_OLD_C32)
continue; continue;
psz_sanpath = sanitize_filename(psz_fullpath, &is_identical); psz_sanpath = sanitize_filename(psz_fullpath, &is_identical);
if (!is_identical) if (!is_identical)
uprintf(" File name sanitized to '%s'\n", psz_sanpath); uprintf(" File name sanitized to '%s'", psz_sanpath);
if (is_symlink) { if (is_symlink) {
if (i_file_length == 0) if (i_file_length == 0)
uprintf(" Ignoring Rock Ridge symbolic link to '%s'\n", p_statbuf->rr.psz_symlink); uprintf(" Ignoring Rock Ridge symbolic link to '%s'", p_statbuf->rr.psz_symlink);
safe_free(p_statbuf->rr.psz_symlink); safe_free(p_statbuf->rr.psz_symlink);
} }
file_handle = CreateFileU(psz_sanpath, GENERIC_READ | GENERIC_WRITE, file_handle = CreateFileU(psz_sanpath, GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL); FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
if (file_handle == INVALID_HANDLE_VALUE) { if (file_handle == INVALID_HANDLE_VALUE) {
err = GetLastError(); err = GetLastError();
uprintf(" Unable to create file: %s\n", WindowsErrorString()); uprintf(" Unable to create file: %s", WindowsErrorString());
if ((err == ERROR_ACCESS_DENIED) && (safe_strcmp(&psz_sanpath[3], autorun_name) == 0)) if ((err == ERROR_ACCESS_DENIED) && (safe_strcmp(&psz_sanpath[3], autorun_name) == 0))
uprintf(stupid_antivirus); uprintf(stupid_antivirus);
else else
@ -570,7 +570,7 @@ static int iso_extract_files(iso9660_t* p_iso, const char *psz_path)
memset(buf, 0, ISO_BLOCKSIZE); memset(buf, 0, ISO_BLOCKSIZE);
lsn = p_statbuf->lsn + (lsn_t)i; lsn = p_statbuf->lsn + (lsn_t)i;
if (iso9660_iso_seek_read(p_iso, buf, lsn, 1) != ISO_BLOCKSIZE) { if (iso9660_iso_seek_read(p_iso, buf, lsn, 1) != ISO_BLOCKSIZE) {
uprintf(" Error reading ISO9660 file %s at LSN %lu\n", uprintf(" Error reading ISO9660 file %s at LSN %lu",
psz_iso_name, (long unsigned int)lsn); psz_iso_name, (long unsigned int)lsn);
goto out; goto out;
} }

7
src/rufus.c
View File

@ -2271,13 +2271,6 @@ static INT_PTR CALLBACK MainCallback(HWND hDlg, UINT message, WPARAM wParam, LPA
#ifdef RUFUS_TEST #ifdef RUFUS_TEST
case IDC_TEST: case IDC_TEST:
{ {
int j;
char str[65];
uint8_t sum[32];
Checksum(CHECKSUM_SHA256, "C:\\rufus\\src\\.msvc\\rufus_files\\syslinux-6.03\\ldlinux.sys", sum);
for (j = 0; j < sizeof(sum); j++)
safe_sprintf(&str[2 * j], ARRAYSIZE(str) - 2 * j, "%02x", sum[j]);
uprintf(" Checksum: %s", str);
break; break;
} }
#endif #endif

5
src/rufus.h
View File

@ -456,7 +456,10 @@ extern BOOL IsFontAvailable(const char* font_name);
extern BOOL WriteFileWithRetry(HANDLE hFile, LPCVOID lpBuffer, DWORD nNumberOfBytesToWrite, extern BOOL WriteFileWithRetry(HANDLE hFile, LPCVOID lpBuffer, DWORD nNumberOfBytesToWrite,
LPDWORD lpNumberOfBytesWritten, DWORD nNumRetries); LPDWORD lpNumberOfBytesWritten, DWORD nNumRetries);
extern BOOL SetThreadAffinity(DWORD_PTR* thread_affinity, size_t num_threads); extern BOOL SetThreadAffinity(DWORD_PTR* thread_affinity, size_t num_threads);
extern BOOL Checksum(const unsigned type, const char* path, uint8_t* sum); extern BOOL HashFile(const unsigned type, const char* path, uint8_t* sum);
extern BOOL HashBuffer(const unsigned type, const unsigned char* buf, const size_t len, uint8_t* sum);
extern BOOL IsFileInDB(const char* path);
extern BOOL IsBufferInDB(const unsigned char* buf, const size_t len);
#define printbits(x) _printbits(sizeof(x), &x, 0) #define printbits(x) _printbits(sizeof(x), &x, 0)
#define printbitslz(x) _printbits(sizeof(x), &x, 1) #define printbitslz(x) _printbits(sizeof(x), &x, 1)
extern char* _printbits(size_t const size, void const * const ptr, int leading_zeroes); extern char* _printbits(size_t const size, void const * const ptr, int leading_zeroes);

10
src/rufus.rc
View File

@ -33,7 +33,7 @@ LANGUAGE LANG_NEUTRAL, SUBLANG_NEUTRAL
IDD_DIALOG DIALOGEX 12, 12, 242, 376 IDD_DIALOG DIALOGEX 12, 12, 242, 376
STYLE DS_SETFONT | DS_MODALFRAME | DS_CENTER | WS_MINIMIZEBOX | WS_POPUP | WS_CAPTION | WS_SYSMENU STYLE DS_SETFONT | DS_MODALFRAME | DS_CENTER | WS_MINIMIZEBOX | WS_POPUP | WS_CAPTION | WS_SYSMENU
EXSTYLE WS_EX_ACCEPTFILES EXSTYLE WS_EX_ACCEPTFILES
CAPTION "Rufus 2.10.939" CAPTION "Rufus 2.10.940"
FONT 8, "Segoe UI Symbol", 400, 0, 0x0 FONT 8, "Segoe UI Symbol", 400, 0, 0x0
BEGIN BEGIN
LTEXT "Device",IDS_DEVICE_TXT,9,6,200,8 LTEXT "Device",IDS_DEVICE_TXT,9,6,200,8
@ -320,8 +320,8 @@ END
// //
VS_VERSION_INFO VERSIONINFO VS_VERSION_INFO VERSIONINFO
FILEVERSION 2,10,939,0 FILEVERSION 2,10,940,0
PRODUCTVERSION 2,10,939,0 PRODUCTVERSION 2,10,940,0
FILEFLAGSMASK 0x3fL FILEFLAGSMASK 0x3fL
#ifdef _DEBUG #ifdef _DEBUG
FILEFLAGS 0x1L FILEFLAGS 0x1L
@ -338,13 +338,13 @@ BEGIN
BEGIN BEGIN
VALUE "CompanyName", "Akeo Consulting (http://akeo.ie)" VALUE "CompanyName", "Akeo Consulting (http://akeo.ie)"
VALUE "FileDescription", "Rufus" VALUE "FileDescription", "Rufus"
VALUE "FileVersion", "2.10.939" VALUE "FileVersion", "2.10.940"
VALUE "InternalName", "Rufus" VALUE "InternalName", "Rufus"
VALUE "LegalCopyright", "© 2011-2016 Pete Batard (GPL v3)" VALUE "LegalCopyright", "© 2011-2016 Pete Batard (GPL v3)"
VALUE "LegalTrademarks", "http://www.gnu.org/copyleft/gpl.html" VALUE "LegalTrademarks", "http://www.gnu.org/copyleft/gpl.html"
VALUE "OriginalFilename", "rufus.exe" VALUE "OriginalFilename", "rufus.exe"
VALUE "ProductName", "Rufus" VALUE "ProductName", "Rufus"
VALUE "ProductVersion", "2.10.939" VALUE "ProductVersion", "2.10.940"
END END
END END
BLOCK "VarFileInfo" BLOCK "VarFileInfo"

8
src/syslinux.c
View File

@ -148,7 +148,8 @@ BOOL InstallSyslinux(DWORD drive_index, char drive_letter, int fs_type)
uprintf("Could not read %s", path); uprintf("Could not read %s", path);
goto out; goto out;
} }
uprintf("Using existing './%s'", path); uprintf("Using existing './%s' %s", path,
IsBufferInDB(syslinux_ldlinux[i], (size_t)syslinux_ldlinux_len[i])?"✓":"✗");
} }
} else { } else {
for (i=0; i<2; i++) { for (i=0; i<2; i++) {
@ -313,8 +314,9 @@ BOOL InstallSyslinux(DWORD drive_index, char drive_letter, int fs_type)
uprintf("Caution: No '%s' was provided. The target will be missing a required Syslinux file!", &path[3]); uprintf("Caution: No '%s' was provided. The target will be missing a required Syslinux file!", &path[3]);
} else { } else {
fclose(fd); fclose(fd);
if (CopyFileA(&path[3], path, TRUE)) { if (CopyFileU(&path[3], path, TRUE)) {
uprintf("Created '%s' (from '%s/%s-%s/%s')", path, FILES_DIR, syslinux, embedded_sl_version_str[1], &path[3]); uprintf("Created '%s' (from '%s/%s-%s/%s') %s", path, FILES_DIR, syslinux,
embedded_sl_version_str[1], &path[3], IsFileInDB(&path[3])?"✓":"✗");
} else { } else {
uprintf("Failed to create '%s': %s", path, WindowsErrorString()); uprintf("Failed to create '%s': %s", path, WindowsErrorString());
} }