librist-sys 0.8.3

Bindgen bindings for librist, used by the librist-rust crate
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

/* librist. Copyright © 2020 SipRadius LLC. All right reserved.
 * Author: Gijs Peskens <gijs@in2ip.nl>
 * Author: Sergio Ammirata, Ph.D. <sergio@ammirata.net>
 *
 * SPDX-License-Identifier: BSD-2-Clause
 */

#include <mbedtls/base64.h>
#include <stddef.h>
#include <stdbool.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

void user_verifier_lookup(char * username,
							size_t *verifier_len, char **verifier,
							size_t *salt_len, char **salt,
							bool *use_default_2048_bit_n_modulus,
							char **n_modulus_ascii,
							char **generator_ascii,
							void *user_data)
{
	(void)n_modulus_ascii;
	(void)generator_ascii;
	if (user_data == NULL)
		return;
	FILE *fh = (FILE *)user_data;
	size_t username_offset = 0;

	size_t read_verifier_len = 0;
	char *read_verifier = malloc(1024);
	size_t read_salt_len = 0;
	char *read_salt = malloc(1024);

	int reading = 0;//0 = username, 1 = verifier, 2 = salt
	bool skipnextline = false;
	int read = getc(fh);
	//expected format: username:verifier:salt:3
	while (read != EOF)
	{
		if (skipnextline)
		{
			if (read == '\n')
				skipnextline = false;
		} else if (read == ':')
		{
			if (reading == 0 && username_offset != (strlen(username))) {
				skipnextline = true;
				username_offset = 0;
				continue;
			}
			if (reading == 1)
				read_verifier[read_verifier_len+1] = '\0';
			else if (reading == 2)
			{
				read_salt[read_salt_len +1] = '\0';
				break;
			}
			reading++;
		}
		else if (reading == 0)
		{
			if (username[username_offset] != read)
			{
				username_offset = 0;
				skipnextline = true;
			}
			 else
				username_offset++;
		} else if (reading == 1)
		{
			if (read_verifier_len == 1024)
				goto out;
			read_verifier[read_verifier_len] = read;
			read_verifier_len++;
		} else if (reading == 2)
		{
			if (read_salt_len == 1024)
				goto out;
			read_salt[read_salt_len] = read;
			read_salt_len++;
		}
		read = getc(fh);
	}
	if (reading != 2)
		goto out;
	//PAD with ==
	if ((read_verifier_len % 4) != 0)
	{
		size_t needed_padding = 4 - (read_verifier_len % 4);
		for (size_t i = 0; i < needed_padding; i++)
			read_verifier[(read_verifier_len + i)] = '=';
		read_verifier_len += needed_padding;
		read_verifier[read_verifier_len] = '\0';
	}
	if ((read_salt_len % 4) != 0)
	{
		size_t needed_padding = 4 - (read_salt_len % 4);
		for (size_t i = 0; i < needed_padding; i++)
			read_salt[(read_salt_len + i)] = '=';
		read_salt_len += needed_padding;
		read_salt[read_salt_len] = '\0';
	}
	char *decoded_verifier = malloc(1024);
	char *decoded_salt = malloc(1024);
	if (mbedtls_base64_decode((unsigned char *)decoded_verifier, 1024, verifier_len, (unsigned char *)read_verifier, read_verifier_len) != 0)
		goto fail_decode;

	if (mbedtls_base64_decode((unsigned char *)decoded_salt, 1024, salt_len, (unsigned char *)read_salt, read_salt_len) != 0)
		goto fail_decode;

	*verifier = decoded_verifier;
	*salt = decoded_salt;
	*use_default_2048_bit_n_modulus = true;
	goto out;

fail_decode:
	*verifier_len = 0;
	*salt_len = 0;
	free(decoded_verifier);
	free(decoded_salt);
out:
	free(read_verifier);
	free(read_salt);
	rewind(fh);
	return;
}