1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
|
/*
* Copyright (c) 2015-2018 Nitrokey UG
*
* This file is part of libnitrokey.
*
* libnitrokey is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* any later version.
*
* libnitrokey 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 Lesser General Public License
* along with libnitrokey. If not, see <http://www.gnu.org/licenses/>.
*
* SPDX-License-Identifier: LGPL-3.0
*/
#include <sstream>
#include <string>
#include "misc.h"
#include "inttypes.h"
#include <cstdlib>
#include <cstring>
#include "LibraryException.h"
#include <vector>
namespace nitrokey {
namespace misc {
::std::vector<uint8_t> hex_string_to_byte(const char* hexString){
const size_t big_string_size = 257; //arbitrary 'big' number
const size_t s_size = strnlen(hexString, big_string_size);
const size_t d_size = s_size/2;
if (s_size%2!=0 || s_size>=big_string_size){
throw InvalidHexString(0);
}
auto data = ::std::vector<uint8_t>();
data.reserve(d_size);
char buf[3];
buf[2] = '\0';
for(size_t i=0; i<s_size; i++){
char c = hexString[i];
bool char_from_range = (('0' <= c && c <='9') || ('A' <= c && c <= 'F') || ('a' <= c && c<= 'f'));
if (!char_from_range){
throw InvalidHexString(c);
}
buf[i%2] = c;
if (i%2==1){
data.push_back( strtoul(buf, NULL, 16) & 0xFF );
}
}
return data;
};
#include <cctype>
::std::string hexdump(const uint8_t *p, size_t size, bool print_header,
bool print_ascii, bool print_empty) {
::std::stringstream out;
char formatbuf[128];
const uint8_t *pstart = p;
for (const uint8_t *pend = p + size; p < pend;) {
if (print_header){
snprintf(formatbuf, 128, "%04x\t", static_cast<int> (p - pstart));
out << formatbuf;
}
const uint8_t* pp = p;
for (const uint8_t *le = p + 16; p < le; p++) {
if (p < pend){
snprintf(formatbuf, 128, "%02x ", uint8_t(*p));
out << formatbuf;
} else {
if(print_empty)
out << "-- ";
}
}
if(print_ascii){
out << " ";
for (const uint8_t *le = pp + 16; pp < le && pp < pend; pp++) {
if (std::isgraph(*pp))
out << uint8_t(*pp);
else
out << '.';
}
}
out << ::std::endl;
}
return out.str();
}
static uint32_t _crc32(uint32_t crc, uint32_t data) {
int i;
crc = crc ^ data;
for (i = 0; i < 32; i++) {
if (crc & 0x80000000)
crc = (crc << 1) ^ 0x04C11DB7; // polynomial used in STM32
else
crc = (crc << 1);
}
return crc;
}
uint32_t stm_crc32(const uint8_t *data, size_t size) {
uint32_t crc = 0xffffffff;
const uint32_t *pend = reinterpret_cast<const uint32_t *>(data + size);
for (const uint32_t *p = reinterpret_cast<const uint32_t *>(data); p < pend; p++)
crc = _crc32(crc, *p);
return crc;
}
}
}
|
