bee2-rs 0.2.1

Bindings for cryptographic library Bee2
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
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157

/*
*******************************************************************************
\file dec.c
\brief Decimal strings
\project bee2 [cryptographic library]
\created 2015.11.09
\version 2015.11.11
\copyright The Bee2 authors
\license Licensed under the Apache License, Version 2.0 (see LICENSE.txt).
*******************************************************************************
*/

#include "bee2/core/dec.h"
#include "bee2/core/mem.h"
#include "bee2/core/str.h"
#include "bee2/core/util.h"
#include "bee2/core/word.h"

/*
*******************************************************************************
Проверка
*******************************************************************************
*/

bool_t decIsValid(const char* dec)
{
	if (!strIsValid(dec))
		return FALSE;
	for (; *dec; ++dec)
		if (*dec < '0' || *dec > '9')
			return FALSE;
	return TRUE;
}

/*
*******************************************************************************
Характеристики
*******************************************************************************
*/

size_t decCLZ(const char* dec)
{
	register size_t clz = 0;
	ASSERT(decIsValid(dec));
	while (*dec == '0')
		++dec, ++clz;
	return clz;
}

/*
*******************************************************************************
Преобразования
*******************************************************************************
*/

void decFromU32(char* dec, size_t count, register u32 num)
{
	ASSERT(memIsValid(dec, count + 1));
	dec[count] = '\0';
	while (count--)
		dec[count] = num % 10 + '0', num /= 10;
}

u32 decToU32(const char* dec)
{
	register u32 num = 0;
	ASSERT(decIsValid(dec));
	while (*dec)
		num *= 10, num += *dec - '0', ++dec;
	return num;
}

#ifdef U64_SUPPORT

void decFromU64(char* dec, size_t count, register u64 num)
{
	ASSERT(memIsValid(dec, count + 1));
	dec[count] = '\0';
	while (count--)
		dec[count] = num % 10 + '0', num /= 10;
}

u64 decToU64(const char* dec)
{
	register u64 num = 0;
	ASSERT(decIsValid(dec));
	while (*dec)
		num *= 10, num += *dec - '0', ++dec;
	return num;
}

#endif // U64_SUPPORT

/*
*******************************************************************************
Контрольные цифры
*******************************************************************************
*/

static const word luhn_table[10] = {0, 2, 4, 6, 8, 1, 3, 5, 7, 9};

char decLuhnCalc(const char* dec)
{
	register word cd = 0;
	size_t i;
	ASSERT(decIsValid(dec));
	for (i = strLen(dec); i--;) 
	{
		cd += luhn_table[dec[i] - '0'];
		if (i)
			cd += dec[--i] - '0';
	}
	cd %= 10, cd = ((cd << 3) + cd) % 10;
	return (char)cd + '0';
}

bool_t decLuhnVerify(const char* dec)
{
	register word cd = 0;
	size_t i;
	ASSERT(decIsValid(dec));
	for (i = strLen(dec); i--;) 
	{
		cd += dec[i] - '0';
		if (i)
			cd += luhn_table[dec[--i] - '0'];
	}
	cd %= 10;
	return wordEq(cd, 0);
}

static const char damm_table[10][10] = {
	{0, 3, 1, 7, 5, 9, 8, 6, 4, 2},
	{7, 0, 9, 2, 1, 5, 4, 8, 6, 3},
	{4, 2, 0, 6, 8, 7, 1, 3, 5, 9},
	{1, 7, 5, 0, 9, 8, 3, 4, 2, 6},
	{6, 1, 2, 3, 0, 4, 5, 9, 7, 8},
	{3, 6, 7, 4, 2, 0, 9, 5, 8, 1},
	{5, 8, 6, 9, 7, 2, 0, 1, 3, 4},
	{8, 9, 4, 5, 3, 6, 2, 0, 1, 7},
	{9, 4, 3, 8, 6, 1, 7, 2, 0, 5},
	{2, 5, 8, 1, 4, 3, 6, 7, 9, 0},
};

char decDammCalc(const char* dec)
{
	register char cd = 0;
	ASSERT(decIsValid(dec));
	for (; *dec; ++dec)
		cd = damm_table[(octet)cd][(octet)(*dec - '0')];
	return cd + '0';
}

bool_t decDammVerify(const char* dec)
{
	return decDammCalc(dec) == '0';
}