Skip to content

Commit 76559bf

Browse files
dkulicdkulic
committed
Merge from master
Signed-off-by: Darko Kulic <[email protected]>
2 parents ee16696 + e5189dd commit 76559bf

File tree

12 files changed

+155
-113
lines changed

12 files changed

+155
-113
lines changed

‎Jenkinsfile.cd‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -707,5 +707,5 @@ def downloadPackagingUtils() {
707707
}
708708

709709
def setupRust() {
710-
sh "rustup default 1.25.0"
710+
sh "rustup default 1.26.0"
711711
}

‎Jenkinsfile.ci‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -423,7 +423,7 @@ def closePool(env_name, network_name, poolInst) {
423423
}
424424

425425
def setupRust() {
426-
sh "rustup default 1.25.0"
426+
sh "rustup default 1.26.0"
427427
}
428428

429429
def setupRustIOS() {

‎libindy/ci/amazon.dockerfile‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -35,7 +35,7 @@ RUN wget https://repos.fedorapeople.org/repos/dchen/apache-maven/epel-apache-mav
3535
RUN sed -i s/\$releasever/6/g /etc/yum.repos.d/epel-apache-maven.repo
3636
RUN yum install -y apache-maven
3737

38-
ENV RUST_ARCHIVE=rust-1.25.0-x86_64-unknown-linux-gnu.tar.gz
38+
ENV RUST_ARCHIVE=rust-1.26.0-x86_64-unknown-linux-gnu.tar.gz
3939
ENV RUST_DOWNLOAD_URL=https://static.rust-lang.org/dist/$RUST_ARCHIVE
4040

4141
RUN mkdir -p /rust

‎libindy/ci/ubuntu.dockerfile‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -46,7 +46,7 @@ RUN apt-get update && apt-get install -y maven
4646
RUN useradd -ms /bin/bash -u $uid indy
4747
USER indy
4848

49-
RUN curl https://sh.rustup.rs -sSf | sh -s -- -y --default-toolchain 1.25.0
49+
RUN curl https://sh.rustup.rs -sSf | sh -s -- -y --default-toolchain 1.26.0
5050
ENV PATH /home/indy/.cargo/bin:$PATH
5151

5252
WORKDIR /home/indy

‎libindy/src/commands/non_secrets.rs‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -295,7 +295,7 @@ impl NonSecretsCommandExecutor {
295295
}
296296

297297
let search_result = SearchRecords {
298-
total_count: None, // TODO: return search.get_total_count()?
298+
total_count: search.get_total_count()?,
299299
records: if records.is_empty() { None } else { Some(records) }
300300
};
301301

‎libindy/src/errors/wallet.rs‎

Lines changed: 18 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -134,6 +134,13 @@ impl ToErrorCode for WalletError {
134134
}
135135
}
136136

137+
138+
impl From<CommonError> for WalletError {
139+
fn from(err: CommonError) -> WalletError {
140+
WalletError::CommonError(err)
141+
}
142+
}
143+
137144
impl From<io::Error> for WalletError {
138145
fn from(err: io::Error) -> WalletError {
139146
WalletError::CommonError(CommonError::IOError(err))
@@ -200,7 +207,8 @@ pub enum WalletStorageError {
200207
ItemAlreadyExists,
201208
IOError(String),
202209
PluggedStorageError(ErrorCode),
203-
CommonError(CommonError)
210+
CommonError(CommonError),
211+
QueryError(WalletQueryError),
204212
}
205213

206214

@@ -241,6 +249,12 @@ impl From<CommonError> for WalletStorageError {
241249
fn from(err: CommonError) -> WalletStorageError {WalletStorageError::CommonError(err)}
242250
}
243251

252+
impl From<WalletQueryError> for WalletStorageError {
253+
fn from(err: WalletQueryError) -> Self {
254+
WalletStorageError::QueryError(err)
255+
}
256+
}
257+
244258
impl error::Error for WalletStorageError {
245259
fn description(&self) -> &str {
246260
match *self {
@@ -252,6 +266,7 @@ impl error::Error for WalletStorageError {
252266
WalletStorageError::PluggedStorageError(_err_code) => "Plugged storage error",
253267
WalletStorageError::IOError(ref s) => s,
254268
WalletStorageError::CommonError(ref e) => e.description(),
269+
WalletStorageError::QueryError(ref e) => e.description(),
255270
}
256271
}
257272
}
@@ -268,6 +283,7 @@ impl fmt::Display for WalletStorageError {
268283
WalletStorageError::IOError(ref s) => write!(f, "IO error occurred during storage operation: {}", s),
269284
WalletStorageError::PluggedStorageError(err_code) => write!(f, "Plugged storage error: {}", err_code as i32),
270285
WalletStorageError::CommonError(ref e) => write!(f, "Common error: {}", e.description()),
286+
WalletStorageError::QueryError(ref e) => write!(f, "Query error: {}", e.description())
271287
}
272288
}
273289
}
@@ -283,7 +299,7 @@ pub enum WalletQueryError {
283299
impl fmt::Display for WalletQueryError {
284300
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
285301
match *self {
286-
WalletQueryError::ParsingErr(ref s) | WalletQueryError::StructureErr(ref s) | WalletQueryError::ValueErr(ref s) => f.write_str(s)
302+
WalletQueryError::ParsingErr(ref s) | WalletQueryError::StructureErr(ref s) | WalletQueryError::ValueErr(ref s) => f.write_str(s),
287303
}
288304
}
289305
}
@@ -300,9 +316,3 @@ impl From<serde_json::Error> for WalletQueryError {
300316
WalletQueryError::ParsingErr(err.to_string())
301317
}
302318
}
303-
304-
impl From<CommonError> for WalletError {
305-
fn from(err: CommonError) -> WalletError {
306-
WalletError::CommonError(err)
307-
}
308-
}

‎libindy/src/services/wallet/language.rs‎

Lines changed: 25 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -80,12 +80,32 @@ pub enum Operator {
8080

8181

8282
impl Operator {
83-
pub fn transform(self, f: &Fn(Operator) -> Operator) -> Operator {
83+
pub fn transform(self, f: &Fn(Operator) -> Result<Operator, WalletQueryError>) -> Result<Operator, WalletQueryError> {
8484
match self {
85-
Operator::And(operators) => f(Operator::And(operators.into_iter().map(|o| Operator::transform(o, f)).collect())),
86-
Operator::Or(operators) => f(Operator::Or(operators.into_iter().map(|o| Operator::transform(o, f)).collect())),
87-
Operator::Not(boxed_operator) => f(Operator::Not(Box::new(Operator::transform(*boxed_operator, f)))),
88-
_ => f(self)
85+
Operator::And(operators) => {
86+
let mut transformed = Vec::new();
87+
88+
for operator in operators {
89+
let transformed_operator = Operator::transform(operator, f)?;
90+
transformed.push(transformed_operator);
91+
}
92+
93+
Ok(Operator::And(transformed))
94+
}
95+
Operator::Or(operators) => {
96+
let mut transformed = Vec::new();
97+
98+
for operator in operators {
99+
let transformed_operator = Operator::transform(operator, f)?;
100+
transformed.push(transformed_operator);
101+
}
102+
103+
Ok(Operator::Or(transformed))
104+
}
105+
Operator::Not(boxed_operator) => {
106+
Ok(Operator::Not(Box::new(Operator::transform(*boxed_operator, f)?)))
107+
}
108+
_ => Ok(f(self)?)
89109
}
90110
}
91111

‎libindy/src/services/wallet/mod.rs‎

Lines changed: 12 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -167,18 +167,17 @@ impl WalletService {
167167
let xtype = storage_type.unwrap_or("default");
168168

169169
let storage_types = self.storage_types.borrow();
170-
if !storage_types.contains_key(xtype) {
171-
return Err(WalletError::UnknownType(xtype.to_string()));
172-
}
170+
let storage_type = match storage_types.get(xtype) {
171+
None => return Err(WalletError::UnknownType(xtype.to_string())),
172+
Some(storage_type) => storage_type,
173+
};
173174

174175
let wallet_path = _wallet_path(name);
175176
let wallet_descriptor_path = _wallet_descriptor_path(name);
176177
if wallet_path.exists() && wallet_descriptor_path.exists() {
177178
return Err(WalletError::AlreadyExists(name.to_string()));
178179
}
179180

180-
let storage_type = storage_types.get(xtype).unwrap();
181-
182181
let mut config = match storage_config {
183182
Some(config) => serde_json::from_str::<serde_json::Value>(config)
184183
.map_err(|err| CommonError::InvalidStructure(format!("Cannot deserialize storage config: {:?}", err)))?,
@@ -229,11 +228,10 @@ impl WalletService {
229228
})?;
230229

231230
let storage_types = self.storage_types.borrow();
232-
if !storage_types.contains_key(descriptor.xtype.as_str()) {
233-
return Err(WalletError::UnknownType(descriptor.xtype));
234-
}
235-
236-
let storage_type = storage_types.get(descriptor.xtype.as_str()).unwrap();
231+
let storage_type = match storage_types.get(descriptor.xtype.as_str()) {
232+
None => return Err(WalletError::UnknownType(descriptor.xtype)),
233+
Some(storage_type) => storage_type
234+
};
237235

238236
let config_json = WalletService::read_config(name)?;
239237

@@ -262,10 +260,10 @@ impl WalletService {
262260
})?;
263261

264262
let storage_types = self.storage_types.borrow();
265-
if !storage_types.contains_key(descriptor.xtype.as_str()) {
266-
return Err(WalletError::UnknownType(descriptor.xtype));
267-
}
268-
let storage_type = storage_types.get(descriptor.xtype.as_str()).unwrap();
263+
let storage_type = match storage_types.get(descriptor.xtype.as_str()) {
264+
None => return Err(WalletError::UnknownType(descriptor.xtype)),
265+
Some(storage_type) => storage_type,
266+
};
269267

270268
let mut wallets = self.wallets.borrow_mut();
271269
if wallets.values().any(|ref wallet| wallet.get_name() == name) {

‎libindy/src/services/wallet/query_encryption.rs‎

Lines changed: 29 additions & 27 deletions
Original file line numberDiff line numberDiff line change
@@ -1,49 +1,51 @@
1-
use super::wallet::Keys;
21
use utils::crypto::chacha20poly1305_ietf::ChaCha20Poly1305IETF;
2+
use errors::wallet::WalletQueryError;
3+
4+
use super::wallet::Keys;
35
use super::language::{Operator,TargetValue,TagName};
46

57

68
// Performs encryption of WQL query
79
// WQL query is provided as top-level Operator
810
// Recursively transforms operators using encrypt_operator function
9-
pub(super) fn encrypt_query(operator: Operator, keys: &Keys) -> Operator {
10-
operator.transform(&|op: Operator| -> Operator {encrypt_operator(op, keys)})
11+
pub(super) fn encrypt_query(operator: Operator, keys: &Keys) -> Result<Operator, WalletQueryError> {
12+
operator.transform(&|op: Operator| -> Result<Operator, WalletQueryError> {encrypt_operator(op, keys)})
1113
}
1214

1315

14-
fn encrypt_operator(op: Operator, keys: &Keys) -> Operator {
16+
fn encrypt_operator(op: Operator, keys: &Keys) -> Result<Operator, WalletQueryError> {
1517
match op {
1618
Operator::Eq(name, value) => {
17-
let (encrypted_name, encrypted_value) = encrypt_name_value(&name, value, keys);
18-
Operator::Eq(encrypted_name, encrypted_value)
19+
let (encrypted_name, encrypted_value) = encrypt_name_value(&name, value, keys)?;
20+
Ok(Operator::Eq(encrypted_name, encrypted_value))
1921
},
2022
Operator::Neq(name, value) => {
21-
let (encrypted_name, encrypted_value) = encrypt_name_value(&name, value, keys);
22-
Operator::Neq(encrypted_name, encrypted_value)
23+
let (encrypted_name, encrypted_value) = encrypt_name_value(&name, value, keys)?;
24+
Ok(Operator::Neq(encrypted_name, encrypted_value))
2325
},
2426
Operator::Gt(name, value) => {
25-
let (encrypted_name, encrypted_value) = encrypt_name_value(&name, value, keys);
26-
Operator::Gt(encrypted_name, encrypted_value)
27+
let (encrypted_name, encrypted_value) = encrypt_name_value(&name, value, keys)?;
28+
Ok(Operator::Gt(encrypted_name, encrypted_value))
2729
},
2830
Operator::Gte(name, value) => {
29-
let (encrypted_name, encrypted_value) = encrypt_name_value(&name, value, keys);
30-
Operator::Gte(encrypted_name, encrypted_value)
31+
let (encrypted_name, encrypted_value) = encrypt_name_value(&name, value, keys)?;
32+
Ok(Operator::Gte(encrypted_name, encrypted_value))
3133
},
3234
Operator::Lt(name, value) => {
33-
let (encrypted_name, encrypted_value) = encrypt_name_value(&name, value, keys);
34-
Operator::Lt(encrypted_name, encrypted_value)
35+
let (encrypted_name, encrypted_value) = encrypt_name_value(&name, value, keys)?;
36+
Ok(Operator::Lt(encrypted_name, encrypted_value))
3537
},
3638
Operator::Lte(name, value) => {
37-
let (encrypted_name, encrypted_value) = encrypt_name_value(&name, value, keys);
38-
Operator::Lte(encrypted_name, encrypted_value)
39+
let (encrypted_name, encrypted_value) = encrypt_name_value(&name, value, keys)?;
40+
Ok(Operator::Lte(encrypted_name, encrypted_value))
3941
},
4042
Operator::Like(name, value) => {
41-
let (encrypted_name, encrypted_value) = encrypt_name_value(&name, value, keys);
42-
Operator::Like(encrypted_name, encrypted_value)
43+
let (encrypted_name, encrypted_value) = encrypt_name_value(&name, value, keys)?;
44+
Ok(Operator::Like(encrypted_name, encrypted_value))
4345
},
4446
Operator::Regex(name, value) => {
45-
let (encrypted_name, encrypted_value) = encrypt_name_value(&name, value, keys);
46-
Operator::Regex(encrypted_name, encrypted_value)
47+
let (encrypted_name, encrypted_value) = encrypt_name_value(&name, value, keys)?;
48+
Ok(Operator::Regex(encrypted_name, encrypted_value))
4749
},
4850
Operator::In(name, values) => {
4951
let name = match name {
@@ -59,29 +61,29 @@ fn encrypt_operator(op: Operator, keys: &Keys) -> Operator {
5961
let mut encrypted_values: Vec<TargetValue> = Vec::new();
6062

6163
for value in values {
62-
encrypted_values.push(encrypt_name_value(&name, value, keys).1);
64+
encrypted_values.push(encrypt_name_value(&name, value, keys)?.1);
6365
}
64-
Operator::In(name, encrypted_values)
66+
Ok(Operator::In(name, encrypted_values))
6567
},
66-
_ => op
68+
_ => Ok(op)
6769
}
6870
}
6971

7072

7173
// Encrypts a single tag name, tag value pair.
7274
// If the tag name is EncryptedTagName enum variant, encrypts both the tag name and the tag value
7375
// If the tag name is PlainTagName enum variant, encrypts only the tag name
74-
fn encrypt_name_value(name: &TagName, value: TargetValue, keys: &Keys) -> (TagName, TargetValue) {
76+
fn encrypt_name_value(name: &TagName, value: TargetValue, keys: &Keys) -> Result<(TagName, TargetValue), WalletQueryError> {
7577
match (name, value) {
7678
(&TagName::EncryptedTagName(ref name), TargetValue::Unencrypted(ref s)) => {
7779
let encrypted_tag_name = ChaCha20Poly1305IETF::encrypt_as_searchable(&name[..], &keys.tag_name_key, &keys.tags_hmac_key);
7880
let encrypted_tag_value = ChaCha20Poly1305IETF::encrypt_as_searchable(s.as_bytes(), &keys.tag_value_key, &keys.tags_hmac_key);
79-
(TagName::EncryptedTagName(encrypted_tag_name), TargetValue::Encrypted(encrypted_tag_value))
81+
Ok((TagName::EncryptedTagName(encrypted_tag_name), TargetValue::Encrypted(encrypted_tag_value)))
8082
},
8183
(&TagName::PlainTagName(ref name), TargetValue::Unencrypted(ref s)) => {
8284
let encrypted_tag_name = ChaCha20Poly1305IETF::encrypt_as_searchable(&name[..], &keys.tag_name_key, &keys.tags_hmac_key);
83-
(TagName::PlainTagName(encrypted_tag_name), TargetValue::Unencrypted(s.clone()))
85+
Ok((TagName::PlainTagName(encrypted_tag_name), TargetValue::Unencrypted(s.clone())))
8486
},
85-
_ => unreachable!()
87+
_ => Err(WalletQueryError::StructureErr("Reached invalid combination of tag name and value while encrypting query".to_string()))
8688
}
8789
}

‎libindy/src/services/wallet/storage/default/mod.rs‎

Lines changed: 12 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -13,6 +13,7 @@ use std::rc::Rc;
1313

1414
use utils::environment::EnvironmentUtils;
1515
use errors::wallet::WalletStorageError;
16+
use errors::common::CommonError;
1617
use services::wallet::language;
1718

1819
use super::{StorageIterator, WalletStorageType, WalletStorage, StorageEntity, EncryptedValue, Tag, TagName, FetchOptions};
@@ -92,7 +93,8 @@ struct TagRetriever<'a> {
9293
encrypted_tags_stmt: rusqlite::Statement<'a>,
9394
}
9495

95-
type TagRetrieverOwned = OwningHandle<Rc<rusqlite::Connection>, Box<TagRetriever<'static>>>;
96+
type TagRetrieverOwned = OwningHandle<Rc<rusqlite::Connection>, Box<TagRetriever<'static>>>
97+
;
9698

9799
impl<'a> TagRetriever<'a> {
98100
fn new_owned(conn: Rc<rusqlite::Connection>) -> Result<TagRetrieverOwned, WalletStorageError> {
@@ -184,7 +186,12 @@ impl StorageIterator for SQLiteStorageIterator {
184186
None
185187
};
186188
let tags = if self.options.retrieve_tags {
187-
Some(self.tag_retriever.as_mut().unwrap().retrieve(row.get(0))?)
189+
match self.tag_retriever {
190+
Some(ref mut tag_retriever) => Some(tag_retriever.retrieve(row.get(0))?),
191+
None => return Err(WalletStorageError::CommonError(
192+
CommonError::InvalidState("Fetch tags option set and tag retriever is None".to_string())
193+
))
194+
}
188195
} else {
189196
None
190197
};
@@ -367,7 +374,7 @@ impl WalletStorage for SQLiteStorage {
367374
match res {
368375
Ok(1) => Ok(()),
369376
Ok(0) => Err(WalletStorageError::ItemNotFound),
370-
Ok(_) => unreachable!(),
377+
Ok(count) => Err(WalletStorageError::CommonError(CommonError::InvalidState(format!("SQLite returned update row count: {}", count)))),
371378
Err(err) => Err(WalletStorageError::from(err)),
372379
}
373380
}
@@ -539,7 +546,7 @@ impl WalletStorage for SQLiteStorage {
539546
};
540547

541548
let total_count: Option<usize> = if search_options.retrieve_total_count.unwrap_or(false) {
542-
let (query_string, query_arguments) = query::wql_to_sql_count(type_, query);
549+
let (query_string, query_arguments) = query::wql_to_sql_count(type_, query)?;
543550

544551
self.conn.query_row(
545552
&query_string,
@@ -556,7 +563,7 @@ impl WalletStorage for SQLiteStorage {
556563
retrieve_type: search_options.retrieve_type.unwrap_or(false),
557564
};
558565

559-
let (query_string, query_arguments) = query::wql_to_sql(type_, query, options);
566+
let (query_string, query_arguments) = query::wql_to_sql(type_, query, options)?;
560567

561568
let statement = self._prepare_statement(&query_string)?;
562569
let tag_retriever = if fetch_options.retrieve_tags {

0 commit comments

Comments
 (0)